class Chef::Knife::ChopTranslate

Public Instance Methods

run() click to toggle source

# File lib/chef/knife/chop_translate.rb, line 31
def run
  $stdout.sync = true
  watch_for_break

  @config[:parts].each{ |p|
    @config[:actions].each{ |a|
      actor = @actors[a]
      raise ChopInternalError.new("Actor for action '#{a.to_s}' cannot be nil!") unless actor
      method = %(#{a.to_s}_#{p.to_s})
      raise ChopInternalError.new "Internal error: Method '#{method}' is not implemented in actor #{actor.class.name}!" unless actor.respond_to?(method,true)
      actor.send(method)
    }
  }
end

Private Instance Methods

getNameArgs(xtra,set,key=nil) click to toggle source

# File lib/chef/knife/chop_translate.rb, line 51
def getNameArgs(xtra,set,key=nil)
  @logger.info "Translating these #{set.map{|name,file| file}.ai} ... "
  name_args = []
  name_args << xtra if xtra != ''
  name_args << key if key
  name_args << set.map{ |name,file|
    file
  }
  name_args.flatten
end
translateSet(set,args={}) click to toggle source

# File lib/chef/knife/chop_translate.rb, line 63
def translateSet(set,args={})
  raise ChopInternalError.new "Incorrect use of translateSet method from #{Kernel.caller[0].ai}. Received #{args.class.name}" unless args.is_a?(Hash)
  raise ChopError.new "Must specify the :resource type" unless args[:resource]
  @logger.debug "Translate set: #{set.ai}"
  unless set.size > 0
    @logger.warn("The translate set is empty!")
    return
  end
  rsrc = args[:resource]
  verb = args[:verb] || "from file"
  xtra = args[:extra] || ''
  cmdp = args[:command] || lambda{|rsrc,verb,xtra|
    %(knife #{rsrc} #{verb} #{xtra})
  }
  filp = args[:fileproc] || lambda{|cmd,name,file|
    # name not used/needed
    %(#{cmd} #{file})
  }
  cmd = callCmdProc(cmdp, rsrc,verb,xtra)

  raise ChopInternalError.new("Translation not possible without using Chef/Knife API") unless @use_knife_api
  argv = "#{rsrc} #{verb}".split(%r(\s+))
  klass= Chef::Knife.subcommand_class_from(argv)
  subc = klass.new()
  subc.config = @config.dup
  subc.config[:logger] =
  subc.logger = @logger

  scna = []
  if args[:aggregate] and @use_knife_api
    if rsrc == 'data bag'
      set.each{|k,v|
        scna << getNameArgs(xtra,v,k)
      }
    else
      scna << getNameArgs(xtra,set)
    end
  else
    scna << set.map{ |name,file|
      if @use_knife_api
        "#{xtra} #{rsrc == 'cookbook' ? name : file}"
      else
        cmd = callCmdProc(filp, cmd, name, file)
        cmd
      end
    }
  end
  unless @config[:dry_run]
    begin
      scna.each{|batch|
        if args[:aggregate] and @use_knife_api
          subc.name_args = batch
          subc.translate()
        else
          batch.each{|a|
            if @use_knife_api
              subc.name_args = a
              subc.translate()
            else
              a.each{|file,cmd|
                execute cmd,"#{File.basename(file)} ... "
              }
            end
          }
        end
      }
    rescue => e
      @logger.error "#{e.class.name} #{e.message}"
      raise e
    end
  end
end
translate_cookbooks() click to toggle source

# File lib/chef/knife/chop_translate.rb, line 157
def translate_cookbooks()
  @logger.info("Cookbooks do not need to be translated to Ruby!")
end
translate_databags() click to toggle source

# File lib/chef/knife/chop_translate.rb, line 150
def translate_databags()
  @logger.warn("Data bags cannot be translated to Ruby! (yet?)")
  #logStep "Translate databags"
  #translateSet(databags(@config,[@config[:translate][0]]), :resource => "data bag", :aggregate => true)
end
translate_environments() click to toggle source

# File lib/chef/knife/chop_translate.rb, line 137
def translate_environments()
  logStep "Translate environments"
  # We are only interested in the ext we are starting with!
  translateSet(environments(@config,[@config[:translate][0]]), :resource => "environment", :aggregate => true)
end
translate_roles() click to toggle source

# File lib/chef/knife/chop_translate.rb, line 144
def translate_roles()
  logStep "Translate roles"
  translateSet(roles(@config,[@config[:translate][0]]), :resource => "role", :aggregate => true)
end