vanagon 0.9.3 → 0.10.0

data/lib/vanagon/component/source/local.rb

@@ -79,7 +79,7 @@ class Vanagon
         # @raise [RuntimeError] an exception is raised if there is no known extraction method for @extension
         def extract(tar = "tar") # rubocop:disable Metrics/AbcSize
           # Extension does not appear to be an archive, so "extract" is a no-op
-          return ':' unless archive_extensions.include?(extension)
+          return ': nothing to extract' unless archive_extensions.include?(extension)
 
           case decompressor
           when "7z"

data/lib/vanagon/environment.rb

@@ -0,0 +1,194 @@
+require 'forwardable'
+
+class Vanagon
+  # Environment is a validating wrapper around a delegated Hash,
+  # analogous to Ruby's built in accessor Env. It's intended to be
+  # used for defining multiple Environments, which can be used and
+  # manipulated the same way a bare Hash would be. We're delegating
+  # instead of subclassing because subclassing from Ruby Core is
+  # inviting calamity -- that stuff is written in C and may not
+  # correspond to assumptions you could safely make about Ruby.
+  class Environment
+    extend Forwardable
+    # @!method []
+    #   @see Hash#[]
+    # @!method keys
+    #   @see Hash#keys
+    # @!method values
+    #   @see Hash#values
+    # @!method empty?
+    #   @see Hash#empty?
+    def_delegators :@data, :[], :keys, :values, :empty?
+
+    # @!method each
+    #   @see Hash#each
+    # @!method each_pair
+    #   @see Hash#each_pair
+    def_delegators :@data, :each, :each_pair, :each_key, :each_value
+    def_delegators :@data, :each_with_index, :each_with_object
+    def_delegators :@data, :map, :flat_map
+
+    # @!method delete
+    #   @see Hash#delete
+    # @!method delete_if
+    #   @see Hash#delete_if
+    def_delegators :@data, :delete, :delete_if
+
+    # @!method to_h
+    #   @see Hash#to_h
+    # @!method to_hash
+    #   @see Hash#to_h
+    def_delegators :@data, :to_h, :to_hash
+
+    # Create a new Environment
+    # @return [Vanagon::Environment] a new Environment, with no defined env. vars.
+    def initialize
+      @data = {}
+    end
+
+    # Associates the value given by value with the key given by key. Keys must
+    # be strings, and should conform to the Open Group's guidelines for portable
+    # shell variable names:
+    #     Environment variable names used by the utilities in the Shell and
+    #     Utilities volume of IEEE Std 1003.1-2001 consist solely of uppercase
+    #     letters, digits, and the '_' (underscore) from the characters defined
+    #     in Portable Character Set and do not begin with a digit.
+    #
+    # Values must be Strings or Integers, and will be stored precisely as given,
+    # so any escaped characters, single or double quotes, or whitespace will be
+    # preserved exactly as passed during assignment.
+    #
+    # @param key [String]
+    # @param value [String, Integer]
+    # @raise [ArgumentError] if key is not a String, or if value is not a
+    #   String or an Integer
+    def []=(key, value)
+      @data.update({ validate_key(key) => validate_value(value) })
+    end
+
+    # Returns a new Environment containing the contents of other_env and the
+    # contents of env.
+    # @param other_env [Environment]
+    # @example Merge two Environments
+    #   >> local = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007fc54d913f38 @data={}>
+    #   >> global = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007fc54b06da70 @data={}>
+    #   >> local['PATH'] = '/usr/local/bin:/usr/bin:/bin'
+    #   >> global['CC'] = 'ccache gcc'
+    #   >> local.merge global
+    #   => #<Vanagon::Environment:0x007fc54b0a72e8 @data={"PATH"=>"/usr/local/bin:/usr/bin:/bin", "CC"=>"ccache gcc"}>
+    def merge(other_env)
+      env_copy = self.dup
+      other_env.each_pair do |k, v|
+        env_copy[k] = v
+      end
+      env_copy
+    end
+    alias update merge
+
+    # Adds the contents of other_env to env.
+    # @param other_env [Environment]
+    # @example Merge two Environments
+    #   >> local = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007f8c68933b08 @data={}>
+    #   >> global = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007f8c644e5640 @data={}>
+    #   >> local['PATH'] = '/usr/local/bin:/usr/bin:/bin'
+    #   >> global['CC'] = 'ccache gcc'
+    #   >> local.merge! global
+    #   => #<Vanagon::Environment:0x007f8c68933b08 @data={"PATH"=>"/usr/local/bin:/usr/bin:/bin", "CC"=>"ccache gcc"}>
+    def merge!(other_env)
+      @data = merge(other_env).instance_variable_get(:@data)
+    end
+
+    # Converts env to an array of "#{key}=#{value}" strings, suitable for
+    # joining into a command.
+    # @example Convert to an Array
+    #   >> local = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007f8c68991258 @data={}>
+    #   >> local['PATH'] = '/usr/local/bin:/usr/bin:/bin'
+    #   => "/usr/local/bin:/usr/bin:/bin"
+    #   >> local['CC'] = 'clang'
+    #   => "clang"
+    #   >> local.to_a
+    #   => ["PATH=\"/usr/local/bin:/usr/bin:/bin\"", "CC=\"clang\""]
+    def to_a(delim = "=")
+      @data.map { |k, v| %(#{k}#{delim}#{v}) }
+    end
+    alias to_array to_a
+
+    # Converts env to a string by concatenating together all key-value pairs
+    # with a single space.
+    # @example Convert to an Array
+    #   >> local = Vanagon::Environment.new
+    #   => #<Vanagon::Environment:0x007f8c68014358 @data={}>
+    #   >> local['PATH'] = '/usr/local/bin:/usr/bin:/bin'
+    #   >> local['CC'] = 'clang'
+    #   >> puts local
+    #   PATH=/usr/local/bin:/usr/bin:/bin
+    #   >>
+    def to_s
+      to_a.join("\s")
+    end
+    alias to_string to_s
+
+    def sanitize_value(str)
+      escaped_variables = str.scan(/\$\$([\w]+)/).flatten
+      return str if escaped_variables.empty?
+
+      warning = [%(Value "#{str}" looks like it's escaping one or more strings for shell interpolation.)]
+      escaped_variables.each { |v| warning.push "\t$$#{v} (will be coerced to $(#{v})" }
+      warning.push <<-eos.undent
+        All environment variables will be resolved by Make; these variables will
+        be unesecaped for now, but you should update your projects parameters.
+      eos
+
+      warn warning.join("\n")
+      str.gsub(/\$\$([\w]+)/, '$(\1)')
+    end
+    private :sanitize_value
+
+    # Validate that a key is a String, that it does not contain invalid
+    #   characters, and that it does not begin with a digit
+    # @param key [String]
+    # @raise [ArgumentError] if key is not a String, if key contains invalid
+    #   characters, or if key begins with a digit
+    def validate_key(str)
+      unless str.is_a?(String)
+        raise ArgumentError,
+              'environment variable Name must be a String'
+      end
+
+      if str[0] =~ /\d/
+        raise ArgumentError,
+              'environment variable Name cannot begin with a digit'
+      end
+
+      invalid_chars = str.scan(/[^\w]/).uniq
+      unless invalid_chars.empty?
+        raise ArgumentError,
+              'environment variable Name contains invalid characters: ' +
+              invalid_chars.map { |char| %("#{char}") }.join(', ')
+      end
+      str
+    end
+    private :validate_key
+
+    # Validate that str is a String or an Integer, and that the value
+    # of str cannot be split into more than a single String by #shellsplit.
+    # @param value [String, Integer]
+    # @raise [ArgumentError] if key is not a String or an Integer
+    def validate_value(str)
+      unless str.is_a?(String) || str.is_a?(Integer)
+        raise ArgumentError,
+              'Value must be a String or an Integer'
+      end
+
+      # sanitize the value, which should look for any Shell escaped
+      # variable names inside of the value.
+      str.is_a?(String) ? sanitize_value(str) : str
+    end
+    private :validate_value
+  end
+end

data/lib/vanagon/platform.rb

@@ -1,3 +1,4 @@
+require 'vanagon/environment'
 require 'vanagon/platform/dsl'
 
 class Vanagon
@@ -39,11 +40,18 @@ class Vanagon
 
     # Hold a string containing the values that a given platform
     # should use when a Makefile is run - resolves to the CFLAGS
-    # and LDFLAGS variables. Should also be extended to support
-    # CXXFLAGS and CPPFLAGS ASAP.
+    # and LDFLAGS variables. This should be changed to take advantage
+    # of the Environment, so that we can better leverage Make's
+    # Implicit Variables:
+    #   https://www.gnu.org/software/make/manual/html_node/Implicit-Variables.html
+    # It should also be extended to support CXXFLAGS and CPPFLAGS ASAP.
     attr_accessor :cflags
     attr_accessor :ldflags
 
+    # The overall Environment that a given platform
+    # should pass to each component
+    attr_accessor :environment
+
     # Stores an Array of OpenStructs, each representing a complete
     # command to be run to install external the needed toolchains
     # and build dependencies for a given target platform.
@@ -191,6 +199,9 @@ class Vanagon
       @os_version = os_version
       @architecture = architecture
       @ssh_port = 22
+      # Environments are like Hashes but with specific constraints
+      # around their keys and values.
+      @environment = Vanagon::Environment.new
       @provisioning = []
       @install ||= "install"
       @target_user ||= "root"

data/lib/vanagon/platform/dsl.rb

@@ -18,16 +18,16 @@ class Vanagon
       #
       # @param name [String] name of the platform
       # @return [Vanagon::Platform::DSL] A DSL object to describe the {Vanagon::Platform}
-      def initialize(name)
-        @name = name
+      def initialize(platform_name)
+        @name = platform_name
       end
 
       # Primary way of interacting with the DSL. Also a simple factory to get the right platform object.
       #
       # @param name [String] name of the platform
       # @param block [Proc] DSL definition of the platform to call
-      def platform(name, &block)
-        @platform = case name
+      def platform(platform_name, &block) # rubocop:disable Metrics/AbcSize
+        @platform = case platform_name
                     when /^aix-/
                       Vanagon::Platform::RPM::AIX.new(@name)
                     when /^(cisco-wrlinux|el|fedora)-/
@@ -51,6 +51,7 @@ class Vanagon
                     end
 
         yield(self)
+        environment 'VANAGON_PLATFORM', platform_name.tr('-', '.')
         @platform
       end
 
@@ -83,6 +84,13 @@ class Vanagon
         method_name.to_s.start_with?('get_') || super
       end
 
+      # Adds an arbitrary environment variable to a Platform, which will be
+      # merged with any environment variables defined by the Project into the
+      # rendered Makefile
+      def environment(key, value)
+        @platform.environment[key] = value
+      end
+
       # Set the path to make for the platform
       #
       # @param make_cmd [String] Full path to the make command for the platform
@@ -127,9 +135,10 @@ class Vanagon
 
       # Set the cross_compiled flag for the platform
       #
-      # @param cxx_flag [Boolean] True if this is a cross-compiled platform
-      def cross_compiled(cxx_flag)
-        @platform.cross_compiled = cxx_flag
+      # @param xcc [Boolean] True if this is a cross-compiled platform
+      def cross_compiled(xcc_flag)
+        @platform.cross_compiled = !!xcc_flag
+        environment 'VANAGON_PLATFORM_XCC', @platform.cross_compiled.to_s
       end
 
       # define an explicit Dist for the platform (most likely used for RPM platforms)
@@ -219,38 +228,38 @@ class Vanagon
       # Set the name of this platform as the vm pooler expects it
       #
       # @param name [String] name of the target template to use from the vmpooler
-      def vmpooler_template(name)
-        @platform.vmpooler_template = name
+      def vmpooler_template(template_name)
+        @platform.vmpooler_template = template_name
       end
 
       # Set the name of this platform as the vm pooler expects it
       #
       # @param name [String] name that the pooler uses for this platform
       # @deprecated Please use vmpooler_template instead, this will be removed in a future vanagon release.
-      def vcloud_name(name)
+      def vcloud_name(cloud_name)
         warn "vcloud_name is a deprecated platform DSL method, and will be removed in a future vanagon release. Please use vmpooler_template instead."
-        self.vmpooler_template(name)
+        self.vmpooler_template(cloud_name)
       end
 
       # Set the name of this platform as always-be-scheduling (ABS) expects it
       #
       # @param name [String] name of the platform to request from always-be-scheduling
-      def abs_resource_name(name)
-        @platform.abs_resource_name = name
+      def abs_resource_name(resource_name)
+        @platform.abs_resource_name = resource_name
       end
 
       # Set the name of the docker image to use
       #
       # @param name [String] name of the docker image to use
-      def docker_image(name)
-        @platform.docker_image = name
+      def docker_image(image_name)
+        @platform.docker_image = image_name
       end
 
       # Set the ami for the platform to use
       #
       # @param ami [String] the ami id used.
-      def aws_ami(ami)
-        @platform.aws_ami = ami
+      def aws_ami(ami_name)
+        @platform.aws_ami = ami_name
       end
 
       # Set the user data used in AWS to do setup. Like cloud-config
@@ -307,6 +316,7 @@ class Vanagon
       # @param user[String] a user string to login with.
       def target_user(user = "root")
         @platform.target_user = user
+        environment 'VANAGON_PLATFORM_USER', user
       end
 
       # Set the target ip address or hostname to start build
@@ -326,9 +336,10 @@ class Vanagon
 
       # Set any codename this platform may have (debian for example)
       #
-      # @param name [String] codename for this platform (squeeze for example)
-      def codename(name)
-        @platform.codename = name
+      # @param codename [String] codename for this platform (squeeze for example)
+      def codename(codename)
+        @platform.codename = codename
+        environment 'VANAGON_PLATFORM_CODENAME', codename
       end
 
       def output_dir(directory)

data/lib/vanagon/project.rb

@@ -1,4 +1,5 @@
 require 'vanagon/component'
+require 'vanagon/environment'
 require 'vanagon/platform'
 require 'vanagon/project/dsl'
 require 'vanagon/utilities'
@@ -7,11 +8,70 @@ require 'ostruct'
 class Vanagon
   class Project
     include Vanagon::Utilities
-    attr_accessor :components, :settings, :platform, :configdir, :name
-    attr_accessor :version, :directories, :license, :description, :vendor
-    attr_accessor :homepage, :requires, :user, :repo, :noarch, :identifier
-    attr_accessor :cleanup, :version_file, :release, :replaces, :provides
-    attr_accessor :conflicts, :bill_of_materials, :retry_count, :timeout
+
+    # Numerous attributes related to the artifact that a given
+    # Vanagon project will produce
+    attr_accessor :name
+    attr_accessor :version
+    attr_accessor :release
+    attr_accessor :license
+    attr_accessor :homepage
+    attr_accessor :vendor
+    attr_accessor :description
+    attr_accessor :components
+    attr_accessor :conflicts
+    attr_accessor :requires
+    attr_accessor :replaces
+    attr_accessor :provides
+
+    # Platform's abstraction is kind of backwards -- we should refactor
+    # how this works, and make it possible for Vanagon to default to all
+    # defined platforms if nothing is specified.
+    attr_accessor :platform
+    attr_accessor :configdir
+    attr_accessor :retry_count
+    attr_accessor :timeout
+
+    # Store any target directories that should be packed up into
+    # the resultant artifact produced by a given Vanagon project.
+    attr_accessor :directories
+
+    # This will define any new users that a project should create
+    attr_accessor :user
+
+    # This is entirely too Puppet centric, and should be refactored out
+    # !depreciate
+    # !refactor
+    attr_accessor :repo
+
+    # Mark a project as being architecture independent
+    attr_accessor :noarch
+
+    # This is macOS specific, and defines the Identifier that macOS should
+    # use when it builds a .pkg
+    attr_accessor :identifier
+
+    # Stores whether or not a project should cleanup as it builds
+    # because the target builder is space-constrained
+    attr_accessor :cleanup
+
+    # Stores whether or not Vanagon should write the project's version
+    # out into a file inside the package -- do we really need this?
+    # !depreciate
+    # !refactor
+    attr_accessor :version_file
+
+    # Stores the location for the bill-of-materials (a receipt of all
+    # files written during) project package assembly
+    attr_accessor :bill_of_materials
+
+    # Stores individual settings related to a given Vanagon project,
+    # not necessarily the artifact that the project produces
+    attr_accessor :settings
+
+    # The overall Environment that a given Vanagon
+    # project should pass to each platform
+    attr_accessor :environment
 
     # Loads a given project from the configdir
     #
@@ -46,6 +106,9 @@ class Vanagon
       @requires = []
       @directories = []
       @settings = {}
+      # Environments are like Hashes but with specific constraints
+      # around their keys and values.
+      @environment = Vanagon::Environment.new
       @platform = platform
       @release = "1"
       @replaces = []
@@ -65,6 +128,17 @@ class Vanagon
       @settings.key?(method_name) || super
     end
 
+    # Merge the platform's Environment into the project's Environment
+    # and return the result. This will produce the top-level Environment
+    # in the Makefile, that all components (and their Make targets)
+    # will inherit from.
+    #
+    # @return [Environment] a new Environment, constructed from merging
+    #   @platform's Environment with the project's environment.
+    def merged_environment
+      environment.merge(@platform.environment)
+    end
+
     # Collects all sources and patches into the provided workdir
     #
     # @param workdir [String] directory to stage sources into
@@ -195,7 +269,7 @@ class Vanagon
     def get_preinstall_actions(pkg_state)
       scripts = @components.map(&:preinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
-        return ':'
+        return ': no preinstall scripts provided'
       else
         return scripts.join("\n")
       end
@@ -212,7 +286,7 @@ class Vanagon
     def get_postinstall_actions(pkg_state)
       scripts = @components.map(&:postinstall_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
-        return ':'
+        return ': no postinstall scripts provided'
       else
         return scripts.join("\n")
       end
@@ -228,7 +302,7 @@ class Vanagon
     def get_preremove_actions(pkg_state)
       scripts = @components.map(&:preremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
-        return ':'
+        return ': no preremove scripts provided'
       else
         return scripts.join("\n")
       end
@@ -244,7 +318,7 @@ class Vanagon
     def get_postremove_actions(pkg_state)
       scripts = @components.map(&:postremove_actions).flatten.compact.select { |s| s.pkg_state.include? pkg_state }.map(&:scripts)
       if scripts.empty?
-        return ':'
+        return ': no postremove scripts provided'
       else
         return scripts.join("\n")
       end
@@ -287,6 +361,14 @@ class Vanagon
       ret_dirs
     end
 
+    # This originally lived in the Makefile.erb template, but it's pretty
+    # domain-inspecific and we should try to minimize assignment
+    # inside an ERB template
+    # @return [Array] all of the paths produced by #get_directories
+    def dirnames
+      get_directories.map(&:path)
+    end
+
     # Get any services registered by components in the project
     #
     # @return [Array] the services provided by components in the project
@@ -380,6 +462,7 @@ class Vanagon
     #
     # @param workdir [String] workdir to put the packaging files into
     def generate_packaging_artifacts(workdir)
+      FileUtils.install File.join(VANAGON_ROOT, "resources", "metrics", "profiling_shell.sh"), File.join(workdir, "profiling_shell.sh"), :mode => 0775
       @platform.generate_packaging_artifacts(workdir, @name, binding)
     end
   end