Class: FPM::Command

Inherits:

Clamp::Command

• Object
• Clamp::Command
• FPM::Command

Includes:

Util

Defined in:

lib/fpm/command.rb

Overview

The main fpm command entry point.

Defined Under Namespace

Classes: Validator

Instance Method Summary

• #execute ⇒ Object

  Execute this command.

• #help(*args) ⇒ Object
• #initialize(*args) ⇒ Command constructor

  A new FPM::Command.

• #run(*args) ⇒ Object

  def execute.

Methods included from Util

#copied_entries, #copy_entry, #default_shell, #expand_pessimistic_constraints, #logger, #mknod_w, #program_exists?, #program_in_path?, #safesystem, #safesystemout, #tar_cmd, #with

Constructor Details

#initialize(*args) ⇒ Command

A new FPM::Command

# File 'lib/fpm/command.rb', line 239

def initialize(*args)
  super(*args)
  @conflicts = []
  @replaces = []
  @provides = []
  @dependencies = []
  @config_files = []
  @directories = []
end

Instance Method Details

#execute ⇒ Object

Execute this command. See Clamp::Command#execute and Clamp’s documentation

# File 'lib/fpm/command.rb', line 250

def execute
  # Short-circuit if someone simply runs `fpm --version`
  if ARGV == [ "--version" ]
    puts FPM::VERSION
    return 0
  end

  logger.level = :warn
  logger.level = :info if verbose? # --verbose
  logger.level = :debug if debug? # --debug
  if log_level
    logger.level = log_level.to_sym
  end


  if (stray_flags = args.grep(/^-/); stray_flags.any?)
    logger.warn("All flags should be before the first argument " \
                 "(stray flags found: #{stray_flags}")
  end

  # Some older behavior, if you specify:
  #   'fpm -s dir -t ... -C somepath'
  # fpm would assume you meant to add '.' to the end of the commandline.
  # Let's hack that. https://github.com/jordansissel/fpm/issues/187
  if input_type == "dir" and args.empty? and !chdir.nil?
    logger.info("No args, but -s dir and -C are given, assuming '.' as input") 
    args << "."
  end

  logger.info("Setting workdir", :workdir => workdir)
  ENV["TMP"] = workdir

  validator = Validator.new(self)
  if !validator.ok?
    validator.messages.each do |message|
      logger.warn(message)
    end

    logger.fatal("Fix the above problems, and you'll be rolling packages in no time!")
    return 1
  end
  input_class = FPM::Package.types[input_type]
  output_class = FPM::Package.types[output_type]

  input = input_class.new

  # Merge in package settings. 
  # The 'settings' stuff comes in from #apply_options, which goes through
  # all the options defined in known packages and puts them into our command.
  # Flags in packages defined as "--foo-bar" become named "--<packagetype>-foo-bar"
  # They are stored in 'settings' as :gem_foo_bar.
  input.attributes ||= {}

  # Iterate over all the options and set their values in the package's
  # attribute hash.
  #
  # Things like '--foo-bar' will be available as pkg.attributes[:foo_bar]
  self.class.declared_options.each do |option|
    with(option.attribute_name) do |attr|
      next if attr == "help"
      # clamp makes option attributes available as accessor methods
      # --foo-bar is available as 'foo_bar'. Put these in the package
      # attributes hash. (See FPM::Package#attributes)
      # 
      # In the case of 'flag' options, the accessor is actually 'foo_bar?'
      # instead of just 'foo_bar'
     
      # If the instance variable @{attr} is defined, then
      # it means the flag was given on the command line.
      flag_given = instance_variable_defined?("@#{attr}")
      input.attributes["#{attr}_given?".to_sym] = flag_given
      attr = "#{attr}?" if !respond_to?(attr) # handle boolean :flag cases
      input.attributes[attr.to_sym] = send(attr) if respond_to?(attr)
      logger.debug("Setting attribute", attr.to_sym => send(attr))
    end
  end

  # Each remaining command line parameter is used as an 'input' argument.
  # For directories, this means paths. For things like gem and python, this
  # means package name or paths to the packages (rails, foo-1.0.gem, django,
  # bar/setup.py, etc)
  args.each do |arg| 
    input.input(arg) 
  end

  # If --inputs was specified, read it as a file.
  if !inputs.nil?
    if !File.exists?(inputs)
      logger.fatal("File given for --inputs does not exist (#{inputs})")
      return 1
    end

    # Read each line as a path
    File.new(inputs, "r").each_line do |line| 
      # Handle each line as if it were an argument
      input.input(line.strip)
    end
  end

  # Override package settings if they are not the default flag values
  # the below proc essentially does:
  #
  # if someflag != default_someflag
  #   input.someflag = someflag
  # end
  set = proc do |object, attribute|
    # if the package's attribute is currently nil *or* the flag setting for this
    # attribute is non-default, use the value.
    if object.send(attribute).nil? || send(attribute) != send("default_#{attribute}")
      logger.info("Setting from flags: #{attribute}=#{send(attribute)}")
      object.send("#{attribute}=", send(attribute))
    end
  end
  set.call(input, :architecture)
  set.call(input, :category)
  set.call(input, :description)
  set.call(input, :epoch)
  set.call(input, :iteration)
  set.call(input, :license)
  set.call(input, :maintainer)
  set.call(input, :name)
  set.call(input, :url)
  set.call(input, :vendor)
  set.call(input, :version)
  set.call(input, :architecture)

  input.conflicts += conflicts
  input.dependencies += dependencies
  input.provides += provides
  input.replaces += replaces
  input.config_files += config_files
  input.directories += directories

  h = {}
  attrs.each do | e |

    s = e.split(':', 2)
    h[s.last] = s.first
  end

  input.attrs = h

  
  script_errors = []
  setscript = proc do |scriptname|
    # 'self.send(scriptname) == self.before_install == --before-install
    # Gets the path to the script
    path = self.send(scriptname)
    # Skip scripts not set
    next if path.nil?

    if !File.exists?(path)
      logger.error("No such file (for #{scriptname.to_s}): #{path.inspect}")
      script_errors << path
    end

    # Load the script into memory.
    input.scripts[scriptname] = File.read(path)
  end

  setscript.call(:before_install)
  setscript.call(:after_install)
  setscript.call(:before_remove)
  setscript.call(:after_remove)
  setscript.call(:before_upgrade)
  setscript.call(:after_upgrade)

  # Bail if any setscript calls had errors. We don't need to log
  # anything because we've already logged the error(s) above.
  return 1 if script_errors.any?

  # Validate the package
  if input.name.nil? or input.name.empty?
    logger.fatal("No name given for this package (set name with '-n', " \
                  "for example, '-n packagename')")
    return 1
  end

  # Convert to the output type
  output = input.convert(output_class)

  # Provide any template values as methods on the package.
  if template_scripts?
    template_value_list.each do |key, value|
      (class << output; self; end).send(:define_method, key) { value }
    end
  end

  # Write the output somewhere, package can be nil if no --package is specified, 
  # and that's OK.
  
  # If the package output (-p flag) is a directory, write to the default file name
  # but inside that directory.
  if ! package.nil? && File.directory?(package)
    package_file = File.join(package, output.to_s)
  else
    package_file = output.to_s(package)
  end

  begin
    output.output(package_file)
  rescue FPM::Package::FileAlreadyExists => e
    logger.fatal(e.message)
    return 1
  rescue FPM::Package::ParentDirectoryMissing => e
    logger.fatal(e.message)
    return 1
  end

  logger.log("Created package", :path => package_file)
  return 0
rescue FPM::Util::ExecutableNotFound => e
  logger.error("Need executable '#{e}' to convert #{input_type} to #{output_type}")
  return 1
rescue FPM::InvalidPackageConfiguration => e
  logger.error("Invalid package configuration: #{e}")
  return 1
rescue FPM::Util::ProcessFailed => e
  logger.error("Process failed: #{e}")
  return 1
ensure
  if debug_workspace?
    # only emit them if they have files
    [input, output].each do |plugin|
      next if plugin.nil?
      [:staging_path, :build_path].each do |pathtype|
        path = plugin.send(pathtype)
        next unless Dir.open(path).to_a.size > 2
        logger.log("plugin directory", :plugin => plugin.type, :pathtype => pathtype, :path => path)
      end
    end
  else
    input.cleanup unless input.nil?
    output.cleanup unless output.nil?
  end
end

#help(*args) ⇒ Object

# File 'lib/fpm/command.rb', line 26

def help(*args)
  return [
    "Intro:",
    "",
    "  This is fpm version #{FPM::VERSION}",
    "",
    "  If you think something is wrong, it's probably a bug! :)",
    "  Please file these here: https://github.com/jordansissel/fpm/issues",
    "",
    "  You can find support on irc (#fpm on freenode irc) or via email with",
    "  fpm-users@googlegroups.com",
    "",

    # Lastly, include the default help output via Clamp.
    super
  ].join("\n")
end

#run(*args) ⇒ Object

def execute

# File 'lib/fpm/command.rb', line 487

def run(*args)
  logger.subscribe(STDOUT)

  # fpm initialization files, note the order of the following array is
  # important, try .fpm in users home directory first and then the current
  # directory
  rc_files = [ ".fpm" ]
  rc_files << File.join(ENV["HOME"], ".fpm") if ENV["HOME"]

  rc_files.each do |rc_file|
    if File.readable? rc_file
      logger.warn("Loading flags from rc file #{rc_file}")
      File.readlines(rc_file).each do |line|
        # reverse becasue 'unshift' pushes onto the left side of the array.
        Shellwords.shellsplit(line).reverse.each do |arg|
          # Put '.fpm'-file flags *before* the command line flags
          # so that we the CLI can override the .fpm flags
          ARGV.unshift(arg)
        end
      end
    end
  end

  super(*args)
rescue FPM::Package::InvalidArgument => e
  logger.error("Invalid package argument: #{e}")
  return 1
end