vanagon 0.3.18

data/lib/vanagon/platform/swix.rb

@@ -0,0 +1,35 @@
+class Vanagon
+  class Platform
+    class RPM
+      class Swix < Vanagon::Platform::RPM
+        # The specific bits used to generate an SWIX package for a given project
+        #
+        # @param project [Vanagon::Project] project to build a SWIX package of
+        # @return [Array] list of commands required to build the SWIX package
+        # for the given project from an rpm
+        def generate_package(project)
+          target_dir = project.repo ? output_dir(project.repo) : output_dir
+
+          commands = super(project)
+          pkgname_swix = package_name(project)
+          pkgname_rpm = pkgname_swix.sub(/swix$/, 'rpm')
+          commands += ["echo 'format: 1' > ./output/#{target_dir}/manifest.txt",
+          "echo \"primaryRpm: #{pkgname_rpm}\" >> ./output/#{target_dir}/manifest.txt",
+          "echo #{pkgname_rpm}-sha1: `sha1sum ./output/#{target_dir}/#{pkgname_rpm}`",
+          "cd ./output/#{target_dir}/ && zip #{pkgname_swix} manifest.txt #{pkgname_rpm}",
+          "rm ./output/#{target_dir}/manifest.txt ./output/#{target_dir}/#{pkgname_rpm}"]
+
+          commands
+        end
+
+        # Method to derive the package name for the project
+        #
+        # @param project [Vanagon::Project] project to name
+        # @return [String] name of the SWIX package for this project
+        def package_name(project)
+          "#{project.name}-#{project.version}-#{project.release}.#{os_name}#{os_version}.#{project.noarch ? 'noarch' : @architecture}.swix"
+        end
+      end
+    end
+  end
+end

data/lib/vanagon/project.rb

@@ -0,0 +1,251 @@
+require 'vanagon/component'
+require 'vanagon/platform'
+require 'vanagon/project/dsl'
+require 'vanagon/utilities'
+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
+
+    # Loads a given project from the configdir
+    #
+    # @param name [String] the name of the project
+    # @param configdir [String] the path to the project config file
+    # @param platform [Vanagon::Platform] platform to build against
+    # @param include_components [List] optional list restricting the loaded components
+    # @return [Vanagon::Project] the project as specified in the project config
+    # @raise if the instance_eval on Project fails, the exception is reraised
+    def self.load_project(name, configdir, platform, include_components = [])
+      projfile = File.join(configdir, "#{name}.rb")
+      code = File.read(projfile)
+      dsl = Vanagon::Project::DSL.new(name, platform, include_components)
+      dsl.instance_eval(code, __FILE__, __LINE__)
+      dsl._project
+    rescue => e
+      puts "Error loading project '#{name}' using '#{projfile}':"
+      puts e
+      puts e.backtrace.join("\n")
+      raise e
+    end
+
+    # Project constructor. Takes just the name. Also sets the @name and
+    # @platform, and initializes @components, @directories and @settings.
+    #
+    # @param name [String] name of the project
+    # @param platform [Vanagon::Platform] platform for the project to be built for
+    # @return [Vanagon::Project] the project with the given name and platform
+    def initialize(name, platform)
+      @name = name
+      @components = []
+      @requires = []
+      @directories = []
+      @settings = {}
+      @platform = platform
+      @release = "1"
+      @replaces = []
+      @provides = []
+    end
+
+    # Magic getter to retrieve settings in the project
+    def method_missing(method, *args)
+      if @settings.has_key?(method)
+        return @settings[method]
+      end
+    end
+
+    # Collects all sources and patches into the provided workdir
+    #
+    # @param workdir [String] directory to stage sources into
+    def fetch_sources(workdir)
+      @components.each do |component|
+        component.get_source(workdir)
+        # Fetch secondary sources
+        component.get_sources(workdir)
+        component.get_patches(workdir)
+      end
+    end
+
+    # Collects any additional files supplied by components
+    #
+    # @return [Array] array of files installed by components of the project
+    def get_files
+      files = []
+      files.push @version_file if @version_file
+      files.push @components.map(&:files).flatten
+      files.flatten.uniq
+    end
+
+    # Collects all of the requires for both the project and its components
+    #
+    # @return [Array] array of runtime requirements for the project
+    def get_requires
+      req = []
+      req << @components.map(&:requires).flatten
+      req << @requires
+      req.flatten.uniq
+    end
+
+    # Collects all of the replacements for the project and its components
+    #
+    # @return [Array] array of package level replacements for the project
+    def get_replaces
+      replaces = []
+      replaces.push @replaces.flatten
+      replaces.push @components.map(&:replaces).flatten
+      replaces.flatten.uniq
+    end
+
+    # Collects all of the provides for the project and its components
+    #
+    # @return [Array] array of package level provides for the project
+    def get_provides
+      provides = []
+      provides.push @provides.flatten
+      provides.push @components.map(&:provides).flatten
+      provides.flatten.uniq
+    end
+
+    # Collects the pre-install actions for the project and it's components
+    #
+    # @return [Array] array of Bourne shell compatible scriptlets to execute
+    def get_preinstall_actions
+      @components.map(&:preinstall_actions).flatten
+    end
+
+    # Collects the post-install actions for the project and it's components
+    #
+    # @return [Array] array of Bourne shell compatible scriptlets to execute
+    def get_postinstall_actions
+      @components.map(&:postinstall_actions).flatten
+    end
+
+    # Collects any configfiles supplied by components
+    #
+    # @return [Array] array of configfiles installed by components of the project
+    def get_configfiles
+      @components.map(&:configfiles).flatten.uniq
+    end
+
+    # Collects any directories declared by the project and components
+    #
+    # @return [Array] the directories in the project and components
+    def get_directories
+      dirs = []
+      dirs.push @directories
+      dirs.push @components.map(&:directories).flatten
+      dirs.flatten.uniq
+    end
+
+    # Gets the highest level directories declared by the project
+    #
+    # @return [Array] the highest level directories that have been declared by the project
+    def get_root_directories
+      dirs = get_directories.map { |dir| dir.path.split('/') }
+      dirs.sort! { |dir1, dir2| dir1.length <=> dir2.length }
+      ret_dirs = []
+
+      dirs.each do |dir|
+        unless ret_dirs.include?(dir.first(dir.length - 1).join('/'))
+          ret_dirs << dir.join('/')
+        end
+      end
+      ret_dirs
+    end
+
+    # Get any services registered by components in the project
+    #
+    # @return [Array] the services provided by components in the project
+    def get_services
+      @components.map(&:service).flatten.compact
+    end
+
+    # Simple utility for determining if the components in the project declare
+    # any services
+    #
+    # @return [True, False] Whether or not there are services declared for this project or not
+    def has_services?
+      !get_services.empty?
+    end
+
+    # Generate a list of all files and directories to be included in a tarball
+    # for the project
+    #
+    # @return [Array] all the files and directories that should be included in the tarball
+    def get_tarball_files
+      files = ['file-list', 'bill-of-materials']
+      files.push get_files.map(&:path)
+      files.push get_configfiles.map(&:path)
+    end
+
+    # Generate a bill-of-materials: a listing of the components and their
+    # versions in the current project
+    #
+    # @return [Array] a listing of component names and versions
+    def generate_bill_of_materials
+      @components.map { |comp| "#{comp.name} #{comp.version}" }.sort
+    end
+
+    # Method to generate the command to create a tarball of the project
+    #
+    # @return [String] cross platform command to generate a tarball of the project
+    def pack_tarball_command
+      tar_root = "#{@name}-#{@version}"
+      ["mkdir -p '#{tar_root}'",
+       %('#{@platform.tar}' -cf - -T #{get_tarball_files.join(" ")} | ( cd '#{tar_root}/'; '#{@platform.tar}' xfp -)),
+       %('#{@platform.tar}' -cf - #{tar_root}/ | gzip -9c > #{tar_root}.tar.gz)].join("\n\t")
+    end
+
+    # Evaluates the makefile template and writes the contents to the workdir
+    # for use in building the project
+    #
+    # @param workdir [String] full path to the workdir to send the evaluated template
+    # @return [String] full path to the generated Makefile
+    def make_makefile(workdir)
+      erb_file(File.join(VANAGON_ROOT, "templates/Makefile.erb"), File.join(workdir, "Makefile"))
+    end
+
+    # Generates a bill-of-materials and writes the contents to the workdir for use in
+    # building the project
+    #
+    # @param workdir [String] full path to the workdir to send the bill-of-materials
+    # @return [String] full path to the generated bill-of-materials
+    def make_bill_of_materials(workdir)
+      File.open(File.join(workdir, 'bill-of-materials'), 'w') { |f| f.puts(generate_bill_of_materials.join("\n")) }
+    end
+
+    # Return a list of the build_dependencies that are satisfied by an internal component
+    #
+    # @param component [Vanagon::Component] component to check for already satisfied build dependencies
+    # @return [Array] a list of the build dependencies for the given component that are satisfied by other components in the project
+    def list_component_dependencies(component)
+      component.build_requires.select { |dep| @components.map(&:name).include?(dep) }
+    end
+
+    # Get the package name for the project on the current platform
+    #
+    # @return [String] package name for the current project as defined by the platform
+    def package_name
+      @platform.package_name(self)
+    end
+
+    # Ascertain how to build a package for the current platform
+    #
+    # @return [String, Array] commands to build a package for the current project as defined by the platform
+    def generate_package
+      @platform.generate_package(self)
+    end
+
+    # Generate any required files to build a package for this project on the
+    # current platform into the provided workdir
+    #
+    # @param workdir [String] workdir to put the packaging files into
+    def generate_packaging_artifacts(workdir)
+      @platform.generate_packaging_artifacts(workdir, @name, binding)
+    end
+  end
+end

data/lib/vanagon/project/dsl.rb

@@ -0,0 +1,218 @@
+require 'vanagon/project'
+require 'vanagon/utilities'
+require 'vanagon/component/source'
+require 'set'
+
+class Vanagon
+  class Project
+    class DSL
+      # Constructor for the DSL object
+      #
+      # @param name [String] name of the project
+      # @param platform [Vanagon::Platform] platform for the project to build against
+      # @param include_components [List] optional list restricting the loaded components
+      # @return [Vanagon::Project::DSL] A DSL object to describe the {Vanagon::Project}
+      def initialize(name, platform, include_components = [])
+        @name = name
+        @project = Vanagon::Project.new(@name, platform)
+        @include_components = include_components.to_set
+      end
+
+      # Primary way of interacting with the DSL
+      #
+      # @param name [String] name of the project
+      # @param block [Proc] DSL definition of the project to call
+      def project(name, &block)
+        block.call(self)
+      end
+
+      # Accessor for the project.
+      #
+      # @return [Vanagon::Project] the project the DSL methods will be acting against
+      def _project
+        @project
+      end
+
+
+      # Project attributes and DSL methods defined below
+      #
+      #
+      # All purpose getter. This object, which is passed to the project block,
+      # won't have easy access to the attributes of the @project, 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
+          @project.send(attribute)
+        elsif @project.settings.has_key?(method)
+          return @project.settings[method]
+        else
+          super
+        end
+      end
+
+      # Sets a key value pair on the settings hash of the project
+      #
+      # @param name [String] name of the setting
+      # @param value [String] value of the setting
+      def setting(name, value)
+        @project.settings[name] = value
+      end
+
+      # Sets the description of the project. Mainly for use in packaging.
+      #
+      # @param descr [String] description of the project
+      def description(descr)
+        @project.description = descr
+      end
+
+      # Resets the name of the project. Is useful for dynamically changing the project name.
+      #
+      # @param the_name [String] name of the project
+      def name(the_name)
+        @project.name = the_name
+      end
+
+      # Sets the homepage for the project. Mainly for use in packaging.
+      #
+      # @param page [String] url of homepage of the project
+      def homepage(page)
+        @project.homepage = page
+      end
+
+      # Sets the run time requirements for the project. Mainly for use in packaging.
+      #
+      # @param req [String] of requirements of the project
+      def requires(req)
+        @project.requires << req
+      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)
+        @project.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)
+        @project.provides << OpenStruct.new(:provide => provide, :version => version)
+      end
+
+      # Sets the version for the project. Mainly for use in packaging.
+      #
+      # @param ver [String] version of the project
+      def version(ver)
+        @project.version = ver.gsub('-', '.')
+      end
+
+      # Sets the release for the project. Mainly for use in packaging.
+      #
+      # @param rel [String] release of the project
+      def release(rel)
+        @project.release = rel
+      end
+
+      # Sets the version for the project based on a git describe of the
+      # directory that holds the configs. Requires that a git tag be present
+      # and reachable from the current commit in that repository.
+      #
+      def version_from_git
+        @project.version = Vanagon::Utilities.git_version(File.expand_path("..", Vanagon::Driver.configdir)).gsub('-', '.')
+      end
+
+      # Sets the vendor for the project. Used in packaging artifacts.
+      #
+      # @param vend [String] vendor or author of the project
+      def vendor(vend)
+        @project.vendor = vend
+      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)
+        @project.directories << Vanagon::Common::Pathname.new(dir, mode: mode, owner: owner, group: group)
+      end
+
+      # Add a user to the project
+      #
+      # @param name [String] name of the user to create
+      # @param group [String] group of the user
+      # @param shell [String] login shell to set for the user
+      # @param is_system [true, false] if the user should be a system user
+      # @param homedir [String] home directory for the user
+      def user(name, group: nil, shell: nil, is_system: false, homedir: nil)
+        @project.user = Vanagon::Common::User.new(name, group, shell, is_system, homedir)
+      end
+
+      # Sets the license for the project. Mainly for use in packaging.
+      #
+      # @param lic [String] the license the project is released under
+      def license(lic)
+        @project.license = lic
+      end
+
+      # Sets the identifier for the project. Mainly for use in OSX packaging.
+      #
+      # @param ident [String] uses the reverse-domain naming convention
+      def identifier(ident)
+        @project.identifier = ident
+      end
+
+      # Adds a component to the project
+      #
+      # @param name [String] name of component to add. must be present in configdir/components and named $name.rb currently
+      def component(name)
+        puts "Loading #{name}"
+        if @include_components.empty? or @include_components.include?(name)
+          component = Vanagon::Component.load_component(name, File.join(Vanagon::Driver.configdir, "components"), @project.settings, @project.platform)
+          @project.components << component
+        end
+      end
+
+      # Adds a target repo for the project
+      #
+      # @param repo [String] name of the target repository to ship to used in laying out the packages on disk
+      def target_repo(repo)
+        @project.repo = repo
+      end
+
+      # Sets the project to be architecture independent, or noarch
+      def noarch
+        @project.noarch = true
+      end
+
+      # Sets up a rewrite rule for component sources for a given protocol
+      #
+      # @param protocol [String] a supported component source type (Http, Git, ...)
+      # @param rule [String, Proc] a rule used to rewrite component source urls
+      def register_rewrite_rule(protocol, rule)
+        Vanagon::Component::Source.register_rewrite_rule(protocol, rule)
+      end
+
+      # Toggle to apply additional cleanup during the build for space constrained systems
+      def cleanup_during_build
+        @project.cleanup = true
+      end
+
+      # This method will write the projects version to a designated file during package creation
+      # @param target [String] a full path to the version file for the project
+      def write_version_file(target)
+        @project.version_file = Vanagon::Common::Pathname.file(target)
+      end
+    end
+  end
+end