vanagon 0.3.18

data/lib/vanagon/component/dsl.rb

@@ -0,0 +1,307 @@
+require 'vanagon/component'
+require 'ostruct'
+require 'json'
+
+class Vanagon
+  class Component
+    class DSL
+      # Constructor for the DSL object
+      #
+      # @param name [String] name of the component
+      # @param settings [Hash] settings to use in building the component
+      # @param platform [Vanagon::Platform] platform to build the component for
+      # @return [Vanagon::Component::DSL] A DSL object to describe the {Vanagon::Component}
+      def initialize(name, settings, platform)
+        @name = name
+        @component = Vanagon::Component.new(@name, settings, platform)
+      end
+
+      # Primary way of interacting with the DSL
+      #
+      # @param name [String] name of the componennt
+      # @param block [Proc] DSL definition of the component to call
+      def component(name, &block)
+        block.call(self, @component.settings, @component.platform)
+      end
+
+      # Accessor for the component.
+      #
+      # @return [Vanagon::Component] the component the DSL methods will be acting against
+      def _component
+        @component
+      end
+
+      # All purpose getter. This object, which is passed to the component block,
+      # won't have easy access to the attributes of the @component, so we make a
+      # getter for each attribute.
+      #
+      # We only magically handle get_ methods, any other methods just get the
+      # standard method_missing treatment.
+      #
+      def method_missing(method, *args)
+        attribute_match = method.to_s.match(/get_(.*)/)
+        if attribute_match
+          attribute = attribute_match.captures.first
+        else
+          super
+        end
+
+        @component.send(attribute)
+      end
+
+      # Set or add to the configure call for the component. The commands required to configure the component before building it.
+      #
+      # @param block [Proc] the command(s) required to configure the component
+      def configure(&block)
+        @component.configure << block.call
+      end
+
+      # Set or add to the build call for the component. The commands required to build the component before installing it.
+      #
+      # @param block [Proc] the command(s) required to build the component
+      def build(&block)
+        @component.build << block.call
+      end
+
+      # Set or add to the install call for the component. The commands required to install the component.
+      #
+      # @param block [Proc] the command(s) required to install the component
+      def install(&block)
+        @component.install << block.call
+      end
+
+      # Setup any specific environment required to configure, build or install the component
+      #
+      # @param block [Proc] the environment required to configure, build or install the component
+      def environment(&block)
+        @component.environment = block.call
+      end
+
+      # Add a patch to the list of patches to apply to the component's source after unpacking
+      #
+      # @param patch [String] Path to the patch that should be applied
+      # @param strip [String, Integer] directory levels to skip in applying patch
+      # @param fuzz [String, Integer] levels of context miss to ignore in applying patch
+      def apply_patch(patch, strip: 1, fuzz: 0)
+        @component.patches << OpenStruct.new('path' => patch, 'strip' => strip.to_s, 'fuzz' => fuzz.to_s)
+      end
+
+      # Loads and parses json from a file. Will treat the keys in the
+      # json as methods to invoke on the component in question
+      #
+      # @param file [String] Path to the json file
+      # @raise [RuntimeError] exceptions are raised if there is no file, if it refers to methods that don't exist, or if it does not contain a Hash
+      def load_from_json(file)
+        if File.exists?(file)
+          data = JSON.parse(File.read(file))
+          raise "Hash required. Got '#{data.class}' when parsing '#{file}'" unless data.is_a?(Hash)
+          data.each do |key, value|
+            if self.respond_to?(key)
+              self.send(key, value)
+            else
+              fail "Component does not have a '#{key}' method to invoke. Maybe your bespoke json has a typo?"
+            end
+          end
+        else
+          fail "Cannot load component data from '#{file}'. It does not exist."
+        end
+      end
+
+      # build_requires adds a requirements to the list of build time dependencies
+      # that will need to be fetched from an external source before this component
+      # can be built. build_requires can also be satisfied by other components in
+      # the same project.
+      #
+      # @param build_requirement [String] a library or other component that is required to build the current component
+      def build_requires(build_requirement)
+        @component.build_requires << build_requirement
+      end
+
+      # requires adds a requirement to the list of runtime requirements for the
+      # component
+      #
+      # @param requirement [String] a package that is required at runtime for this component
+      def requires(requirement)
+        @component.requires << requirement
+      end
+
+      # Indicates that this component replaces a system level package. Replaces can be collected and used by the project and package.
+      #
+      # @param replacement [String] a package that is replaced with this component
+      # @param version [String] the version of the package that is replaced
+      def replaces(replacement, version = nil)
+        @component.replaces << OpenStruct.new(:replacement => replacement, :version => version)
+      end
+
+      # Indicates that this component provides a system level package. Provides can be collected and used by the project and package.
+      #
+      # @param provide [String] a package that is provided with this component
+      # @param version [String] the version of the package that is provided with this component
+      def provides(provide, version = nil)
+        @component.provides << OpenStruct.new(:provide => provide, :version => version)
+      end
+
+      # install_service adds the commands to install the various files on
+      # disk during the package build and registers the service with the project
+      #
+      # @param service_file [String] path to the service file relative to the source
+      # @param default_file [String] path to the default file relative to the source
+      # @param service_name [String] name of the service
+      # @param service_type [String] type of the service (network, application, system, etc)
+      def install_service(service_file, default_file = nil, service_name = @component.name, service_type: nil)
+        case @component.platform.servicetype
+        when "sysv"
+          target_service_file = File.join(@component.platform.servicedir, service_name)
+          target_default_file = File.join(@component.platform.defaultdir, service_name)
+          target_mode = '0755'
+          default_mode = '0644'
+        when "systemd"
+          target_service_file = File.join(@component.platform.servicedir, "#{service_name}.service")
+          target_default_file = File.join(@component.platform.defaultdir, service_name)
+          target_mode = '0644'
+          default_mode = '0644'
+        when "launchd"
+          target_service_file = File.join(@component.platform.servicedir, "#{service_name}.plist")
+          target_mode = '0644'
+          default_mode = '0644'
+        when "smf"
+          target_service_file = File.join(@component.platform.servicedir, service_type.to_s, "#{service_name}.xml")
+          target_default_file = File.join(@component.platform.defaultdir, service_name)
+          target_mode = '0644'
+          default_mode = '0755'
+        when "aix"
+          @component.service = OpenStruct.new(:name => service_name, :service_command => File.read(service_file).chomp)
+          # Return here because there is no file to install, just a string read in
+          return
+        else
+          fail "Don't know how to install the #{@component.platform.servicetype}. Please teach #install_service how to do this."
+        end
+
+        # Install the service and default files
+        install_file(service_file, target_service_file, mode: target_mode)
+
+        if default_file
+          install_file(default_file, target_default_file, mode: default_mode)
+          configfile target_default_file
+        end
+
+        # Register the service for use in packaging
+        @component.service = OpenStruct.new(:name => service_name, :service_file => target_service_file)
+      end
+
+      # Copies a file from source to target during the install phase of the component
+      #
+      # @param source [String] path to the file to copy
+      # @param target [String] path to the desired target of the file
+      # @param owner  [String] owner of the file
+      # @param group  [String] group owner of the file
+      def install_file(source, target, mode: '0644', owner: nil, group:  nil)
+        @component.install << "#{@component.platform.install} -d '#{File.dirname(target)}'"
+        @component.install << "cp -p '#{source}' '#{target}'"
+        @component.add_file Vanagon::Common::Pathname.file(target, mode: mode, owner: owner, group: group)
+      end
+
+      # Marks a file as a configfile to ensure that it is not overwritten on
+      # upgrade if it has been modified
+      #
+      # @param file [String] name of the configfile
+      def configfile(file)
+        # I AM SO SORRY
+        @component.delete_file "#{file}"
+        if @component.platform.name =~ /solaris-10|osx/
+          @component.install << "mv '#{file}' '#{file}.pristine'"
+          @component.add_file Vanagon::Common::Pathname.configfile("#{file}.pristine")
+        else
+          @component.add_file Vanagon::Common::Pathname.configfile(file)
+        end
+      end
+
+      # Shorthand to install a file and mark it as a configfile
+      #
+      # @param source [String] path to the configfile to copy
+      # @param target [String] path to the desired target of the configfile
+      def install_configfile(source, target)
+        install_file(source, target)
+        configfile(target)
+      end
+
+      # link will add a command to the install to create a symlink from source to target
+      #
+      # @param source [String] path to the file to symlink
+      # @param target [String] path to the desired symlink
+      def link(source, target)
+        @component.install << "#{@component.platform.install} -d '#{File.dirname(target)}'"
+        @component.install << "ln -s '#{source}' '#{target}'"
+      end
+
+      # Sets the version for the component
+      #
+      # @param ver [String] version of the component
+      def version(ver)
+        @component.version = ver
+      end
+
+      # Sets the url for the source of this component
+      #
+      # @param the_url [String] the url to the source for this component
+      def url(the_url)
+        @component.url = the_url
+      end
+
+      # Sets the md5 sum to verify the sum of the source
+      #
+      # @param md5 [String] md5 sum of the source for verification
+      def md5sum(md5)
+        @component.options[:sum] = md5
+      end
+
+      # Sets the ref of the source for use in a git source
+      #
+      # @param the_ref [String] ref, sha, branch or tag to checkout for a git source
+      def ref(the_ref)
+        @component.options[:ref] = the_ref
+      end
+
+      # This will add a source to the project and put it in the workdir alongside the other sources
+      #
+      # @param url [String] url of the source
+      # @param ref [String] Used for git sources, must be a git ref of some sort
+      # @param sum [String] sum used to validate http and file sources
+      def add_source(url, ref: nil, sum: nil)
+        @component.sources << OpenStruct.new(:url => url, :ref => ref, :sum => sum)
+      end
+
+      # Adds a directory to the list of directories provided by the project, to be included in any packages of the project
+      #
+      # @param dir [String] directory to add to the project
+      # @param mode [String] octal mode to apply to the directory
+      # @param owner [String] owner of the directory
+      # @param group [String] group of the directory
+      def directory(dir, mode: nil, owner: nil, group: nil)
+        @component.directories << Vanagon::Common::Pathname.new(dir, mode: mode, owner: owner, group: group)
+      end
+
+      # Adds a set of environment overrides to the environment for a component.
+      # This environment is included in the configure, build and install steps.
+      #
+      # @param env [Hash] mapping of keys to values to add to the environment for the component
+      def environment(env)
+        @component.environment.merge!(env)
+      end
+
+      # Adds actions to run at the beginning of a package install
+      #
+      # @param action [String] Bourne shell compatible scriptlets to execute
+      def add_preinstall_action(action)
+        @component.preinstall_actions << action
+      end
+
+      # Adds actions to run at the end of a package install
+      #
+      # @param action [String] Bourne shell compatible scriptlets to execute
+      def add_postinstall_action(action)
+        @component.postinstall_actions << action
+      end
+    end
+  end
+end

data/lib/vanagon/component/source.rb

@@ -0,0 +1,66 @@
+require 'vanagon/component/source/http'
+require 'vanagon/component/source/git'
+
+class Vanagon
+  class Component
+    class Source
+      SUPPORTED_PROTOCOLS = ['file', 'http', 'git']
+      @@rewrite_rule = {}
+
+      def self.register_rewrite_rule(protocol, rule)
+        if rule.is_a?(String) or rule.is_a?(Proc)
+          if SUPPORTED_PROTOCOLS.include?(protocol)
+            @@rewrite_rule[protocol] = rule
+          else
+            raise Vanagon::Error, "#{protocol} is not a supported protocol for rewriting"
+          end
+        else
+          raise Vanagon::Error, "String or Proc is required as a rewrite_rule."
+        end
+      end
+
+      def self.rewrite(url, protocol)
+        rule = @@rewrite_rule[protocol]
+        if rule
+          if rule.is_a?(Proc) and rule.arity == 1
+            return rule.call(url)
+          elsif rule.is_a?(String)
+            target_match = url.match(/.*\/([^\/]*)$/)
+            if target_match
+              target = target_match[1]
+              return File.join(rule, target)
+            else
+              raise Vanagon::Error, "Unable to apply url rewrite to '#{url}', expected to find at least one '/' in the url."
+            end
+          else
+          end
+        else
+          return url
+        end
+      end
+
+      # Basic factory to hand back the correct {Vanagon::Component::Source} subtype to the component
+      #
+      # @param url [String] URL to the source (includes git@... style links)
+      # @param options [Hash] hash of the options needed for the subtype
+      # @param workdir [String] working directory to fetch the source into
+      # @return [Vanagon::Component::Source] the correct subtype for the given source
+      def self.source(url, options, workdir)
+        url_match = url.match(/^(.*)(@|:\/\/)(.*)$/)
+        uri_scheme = url_match[1] if url_match
+        local_source =  case uri_scheme
+                        when /^http/
+                          Vanagon::Component::Source::Http.new(self.rewrite(url, 'http'), options[:sum], workdir)
+                        when /^file/
+                          Vanagon::Component::Source::Http.new(self.rewrite(url, 'file'), options[:sum], workdir)
+                        when /^git/
+                          Vanagon::Component::Source::Git.new(self.rewrite(url, 'git'), options[:ref], workdir)
+                        else
+                          fail "Don't know how to handle source of type '#{uri_scheme}' from url: '#{url}'"
+                        end
+
+        return local_source
+      end
+    end
+  end
+end

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

@@ -0,0 +1,60 @@
+require 'vanagon/utilities'
+
+class Vanagon
+  class Component
+    class Source
+      class Git
+        include Vanagon::Utilities
+        attr_accessor :url, :ref, :workdir, :version, :cleanup
+
+        # Constructor for the Git source type
+        #
+        # @param url [String] url of git repo to use as source
+        # @param ref [String] ref to checkout from git repo
+        # @param workdir [String] working directory to clone into
+        def initialize(url, ref, workdir)
+          unless ref
+            fail "ref parameter is required for the git source"
+          end
+          @url = url
+          @ref = ref
+          @workdir = workdir
+        end
+
+        # Fetch the source. In this case, clone the repository into the workdir
+        # and check out the ref. Also sets the version if there is a git tag as
+        # a side effect.
+        def fetch
+          puts "Cloning ref '#{@ref}' from url '#{@url}'"
+          Dir.chdir(@workdir) do
+            git('clone', @url)
+            Dir.chdir(dirname) do
+              git('checkout', @ref)
+              git('submodule', 'update', '--init', '--recursive')
+              @version = git_version
+            end
+          end
+        end
+
+        # Return the correct incantation to cleanup the source directory for a given source
+        #
+        # @return [String] command to cleanup the source
+        def cleanup
+          "rm -rf #{dirname}"
+        end
+
+        # There is no md5 to manually verify here, so it is a noop.
+        def verify
+          # nothing to do here, so just return
+        end
+
+        # The dirname to reference when building from the repo
+        #
+        # @return [String] the directory where the repo was cloned
+        def dirname
+          File.basename(@url).sub(/\.git/, '')
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,158 @@
+require 'vanagon/utilities'
+require 'net/http'
+require 'uri'
+
+class Vanagon
+  class Component
+    class Source
+      class Http
+        include Vanagon::Utilities
+        attr_accessor :url, :sum, :file, :extension, :workdir, :cleanup
+
+        # Extensions for files we intend to unpack during the build
+        ARCHIVE_EXTENSIONS = '.tar.gz', '.tgz'
+
+        # Extensions for files we aren't going to unpack during the build
+        NON_ARCHIVE_EXTENSIONS = '.gem', '.ru', '.txt', '.conf', '.ini', '.gpg', '.rb', '.sh', '.csh'
+
+        # Constructor for the Http source type
+        #
+        # @param url [String] url of the http source to fetch
+        # @param sum [String] sum to verify the download against
+        # @param workdir [String] working directory to download into
+        # @raise [RuntimeError] an exception is raised is sum is nil
+        def initialize(url, sum, workdir)
+          unless sum
+            fail "sum is required to validate the http source"
+          end
+          @url = url
+          @sum = sum
+          @workdir = workdir
+        end
+
+        # Download the source from the url specified. Sets the full path to the
+        # file as @file and the @extension for the file as a side effect.
+        def fetch
+          @file = download
+          @extension = get_extension
+        end
+
+        # Verify the downloaded file matches the provided sum
+        #
+        # @raise [RuntimeError] an exception is raised if the sum does not match the sum of the file
+        def verify
+          puts "Verifying file: #{@file} against sum: '#{@sum}'"
+          actual = get_md5sum(File.join(@workdir, @file))
+          unless @sum == actual
+            fail "Unable to verify '#{@file}'. Expected: '#{@sum}', got: '#{actual}'"
+          end
+        end
+
+        # Downloads the file from @url into the @workdir
+        #
+        # @raise [RuntimeError, Vanagon::Error] an exception is raised if the URI scheme cannot be handled
+        def download
+          uri = URI.parse(@url)
+          target_file = File.basename(uri.path)
+          puts "Downloading file '#{target_file}' from url '#{@url}'"
+
+          case uri.scheme
+          when 'http', 'https'
+            Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == 'https') do |http|
+              request = Net::HTTP::Get.new(uri)
+
+              http.request request do |response|
+                unless response.is_a? Net::HTTPSuccess
+                  fail "Error: #{response.code.to_s}. Unable to get source from #{@url}"
+                end
+                open(File.join(@workdir, target_file), 'w') do |io|
+                  response.read_body do |chunk|
+                    io.write(chunk)
+                  end
+                end
+              end
+            end
+          when 'file'
+            uri = @url.match(/^file:\/\/(.*)$/)
+            if uri
+              source_file = uri[1]
+              target_file = File.basename(source_file)
+              FileUtils.cp(source_file, File.join(@workdir, target_file))
+            else
+              raise Vanagon::Error, "Unable to parse '#{@url}' for local file path."
+            end
+          else
+            fail "Unable to download files using the uri scheme '#{uri.scheme}'. Maybe you have a typo or need to teach me a new trick?"
+          end
+
+          target_file
+
+        rescue Errno::ETIMEDOUT, Timeout::Error, Errno::EINVAL,
+          Errno::EACCES, Errno::ECONNRESET, EOFError, Net::HTTPBadResponse,
+          Net::HTTPHeaderSyntaxError, Net::ProtocolError => e
+          raise Vanagon::Error.wrap(e, "Problem downloading #{target_file} from '#{@url}'. Please verify you have the correct uri specified.")
+        end
+
+        # Gets the command to extract the archive given if needed (uses @extension)
+        #
+        # @param tar [String] the tar command to use
+        # @return [String, nil] command to extract the source
+        # @raise [RuntimeError] an exception is raised if there is no known extraction method for @extension
+        def extract(tar)
+          if ARCHIVE_EXTENSIONS.include?(@extension)
+            return "gunzip -c '#{@file}' | '#{tar}' xf -"
+          elsif NON_ARCHIVE_EXTENSIONS.include?(@extension)
+            # Don't need to unpack gems, ru, txt, conf, ini, gpg
+            return nil
+          else
+            fail "Extraction unimplemented for '#{@extension}' in source '#{@file}'. Please teach me."
+          end
+        end
+
+        # Return the correct incantation to cleanup the source archive and source directory for a given source
+        #
+        # @return [String] command to cleanup the source
+        # @raise [RuntimeError] an exception is raised if there is no known extraction method for @extension
+        def cleanup
+          if ARCHIVE_EXTENSIONS.include?(@extension)
+            return "rm #{@file}; rm -r #{dirname}"
+          elsif NON_ARCHIVE_EXTENSIONS.include?(@extension)
+            # Because dirname will be ./ here, we don't want to try to nuke it
+            return "rm #{@file}"
+          else
+            fail "Don't know how to cleanup for '#{@file}' with extension: '#{@extension}'. Please teach me."
+          end
+        end
+
+        # Returns the extension for @file
+        #
+        # @return [String] the extension of @file
+        # @raise [RuntimeError] an exception is raised if the extension isn't in the current list
+        def get_extension
+          extension_match = @file.match(/.*(#{Regexp.union(ARCHIVE_EXTENSIONS + NON_ARCHIVE_EXTENSIONS)})/)
+          unless extension_match
+            fail "Unrecognized extension for '#{@file}'. Don't know how to extract this format. Please teach me."
+          end
+
+          extension_match[1]
+        end
+
+        # The dirname to reference when building from the source
+        #
+        # @return [String] the directory that should be traversed into to build this source
+        # @raise [RuntimeError] if the @extension for the @file isn't currently handled by the method
+        def dirname
+          if ARCHIVE_EXTENSIONS.include?(@extension)
+            return @file.chomp(@extension)
+          elsif NON_ARCHIVE_EXTENSIONS.include?(@extension)
+            # Because we cd into the source dir, using ./ here avoids special casing single file
+            # sources in the Makefile
+            return './'
+          else
+            fail "Don't know how to guess dirname for '#{@file}' with extension: '#{@extension}'. Please teach me."
+          end
+        end
+      end
+    end
+  end
+end