vanagon 0.4.1 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 71209b38d92410c93fd14043757199b43b7eb354
-  data.tar.gz: 00e90c362e4e79b5301c8c2ca25d4e34756cc2c5
+  metadata.gz: 0277e8af73f3165f6e9b9dac09f09afbf92257d1
+  data.tar.gz: b6d18711b68b4ca2ce845bb1cae01bbf019dfd90
 SHA512:
-  metadata.gz: a416ecdf1e5c8d44250d9dd4192ec0d9d45c711fab197a444739bd7c711644baa9c8541488293151e5bb96a10b3fc615997ccf1bf92718e666214773aee4634b
-  data.tar.gz: 6e8aa16121c6d1c5a97abbe5569f98b032137402282d135e210c40b3981846e6f248a520a5ca1a38e2d9cf548d8ec398363c1f04e5e270c5e75bd6e382dde8bb
+  metadata.gz: b8cccacd01204b1474944ec8975597369883ea354e71e58724802ab27b2581af7a009dd3ab07fe770fadd121180fb35b53bed8ae6bd409b3e031839c5d353d4d
+  data.tar.gz: a8b4f78d37aa2844f1615b7aded498e6c5ca47c5d34d5a18e229125062928d1c6033d9bb97beb3725a1bfeb2250bf714262af187d2509014b4573e18c95bf338

data/README.md

@@ -84,6 +84,7 @@ Currently supported engines are:
 * `local` - Build on the local machine; platform name must match the local machine
 * `docker` - Builds in a docker container
 * `pooler` - Selects a vm from Puppet Labs' vm pooler to build on
+* `hardware` - Build on a specific taget and lock it in redis
 
 #### Flags (can be anywhere in the command)
 
@@ -110,6 +111,13 @@ Used in conjunction with the pooler engine, this is a token to pass to the
 vmpooler to access the API. Without this token, the default lifetime of vms
 will be much shorter.
 
+##### LOCK\_MANAGER\_HOST
+The name of the host where redis is running. Redis is used to handle a lock
+when using the hardware engine. It defaults to *redis*, with no domain.
+
+#### LOCK\_MANAGER\_PORT
+Port of the system where redis is running. Defaults to *6379*.
+
 #### Example usage
 `build --preserve puppet-agent el-6-i386` will build the puppet-agent project
 on the el-6-i386 platform and leave the host intact afterward.

data/bin/build

@@ -2,7 +2,7 @@
 load File.expand_path(File.join(File.dirname(__FILE__), "..", "lib", "vanagon.rb"))
 
 optparse = Vanagon::OptParse.new("#{File.basename(__FILE__)} <project-name> <platform-name> [<target>] [options]",
-                                 [:workdir, :configdir, :engine, :preserve, :verbose])
+                                 [:workdir, :configdir, :engine, :preserve, :verbose, :skipcheck])
 options = optparse.parse! ARGV
 
 project = ARGV[0]

data/lib/makefile.rb

@@ -0,0 +1,67 @@
+class Makefile
+
+  # The Rule class defines a single Makefile rule.
+  #
+  # @see http://www.gnu.org/software/make/manual/make.html#Rule-Introduction
+  class Rule
+
+    # @!attribute [rw] target
+    #   @return [String] The target generated by this rule.
+    attr_accessor :target
+
+    # @!attribute [rw] dependencies
+    #   @return [Array<String>] A list of dependencies that this rule depends on.
+    attr_accessor :dependencies
+
+    # @!attribute [rw] recipe
+    #   @return [Array<String>] A list of commands to execute upon invocation of this rule.
+    attr_accessor :recipe
+
+    # Create a new Makefile rule. When a block is provided then it is called and passed the
+    # newly created Rule object.
+    #
+    # @overload initialize(target, dependencies: [], recipe: [])
+    #   @param target [String] target
+    #   @param dependencies [Array<String>]]
+    #   @param recipe [Array<String>]
+    #
+    # @overload initialize(target, dependencies: [], recipe: [], &block)
+    #   @param target [String] target
+    #   @param dependencies [Array<String>]]
+    #   @param recipe [Array<String>]
+    #   @yieldparam rule [Makefile::Rule]
+    #
+    #   @example Providing a block to #initialize
+    #     newrule = Makefile::Rule.new("test", dependencies: ["all"]) do |rule|
+    #       rule.recipe = [
+    #         "make test",
+    #         "make cpplint",
+    #       ]
+    #     end
+    def initialize(target, dependencies: [], recipe: [], &block)
+      @target = target
+      @dependencies = dependencies
+      @recipe = recipe
+
+      block.call(self) if block
+    end
+
+    # Format this rule as a Makefile rule.
+    #
+    # Recipes that have multiline statements will have tabs inserted after each
+    # newline to ensure that the recipe is parsed as part of a single makefile rule.
+    #
+    # @return [String]
+    def format
+      s = @target + ":"
+      unless @dependencies.empty?
+        s << " " << @dependencies.join(" ")
+      end
+      s << "\n"
+      s << @recipe.map { |line| "\t" + line.gsub("\n", "\n\t") + "\n" }.join
+      s
+    end
+
+    alias to_s format
+  end
+end

data/lib/vanagon/component.rb

@@ -1,13 +1,14 @@
 require 'vanagon/component/source'
 require 'vanagon/component/dsl'
+require 'vanagon/component/rules'
 
 class Vanagon
   class Component
     # @!attribute [r] files
     #   @return [Set] the list of files marked for installation
 
-    attr_accessor :name, :version, :source, :url, :configure, :build, :install
-    attr_accessor :environment, :extract_with, :dirname, :build_requires
+    attr_accessor :name, :version, :source, :url, :configure, :build, :check, :install
+    attr_accessor :environment, :extract_with, :dirname, :build_requires, :build_dir
     attr_accessor :settings, :platform, :patches, :requires, :service, :options
     attr_accessor :directories, :replaces, :provides, :cleanup_source, :environment
     attr_accessor :sources, :preinstall_actions, :postinstall_actions
@@ -50,6 +51,7 @@ class Vanagon
       @configure = []
       @install = []
       @build = []
+      @check = []
       @patches = []
       @files = Set.new
       @directories = []
@@ -121,6 +123,14 @@ class Vanagon
       end
     end
 
+    # Expands the build directory
+    def get_build_dir
+      if @build_dir
+        File.join(@dirname, @build_dir)
+      else
+        @dirname
+      end
+    end
 
     # Fetches secondary sources for the component. These are just dumped into the workdir currently.
     #
@@ -156,5 +166,9 @@ class Vanagon
         "export #{env.join(' ')}"
       end
     end
+
+    def rules(project, platform)
+      Vanagon::Component::Rules.new(self, project, platform)
+    end
   end
 end

data/lib/vanagon/component/dsl.rb

@@ -1,4 +1,5 @@
 require 'vanagon/component'
+require 'vanagon/patch'
 require 'ostruct'
 require 'json'
 
@@ -56,13 +57,20 @@ class Vanagon
         @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.
+      # Set or add to the build call for the component. The commands required to build the component before testing/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 check call for the component. The commands required to test the component before installing it.
+      #
+      # @param block [Proc] the command(s) required to test the component
+      def check(&block)
+        @component.check << 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
@@ -80,10 +88,12 @@ class Vanagon
       # 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 destination [String] Path to the location where the patch 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)
+      # @param after [String] the location in the makefile where the patch command should be run
+      def apply_patch(patch, destination: @component.dirname, strip: 1, fuzz: 0, after: 'unpack')
+        @component.patches << Vanagon::Patch.new(patch, strip, fuzz, after, destination)
       end
 
       # Loads and parses json from a file. Will treat the keys in the
@@ -263,6 +273,27 @@ class Vanagon
         @component.options[:ref] = the_ref
       end
 
+      # Set a build dir relative to the source directory.
+      #
+      # The build dir will be created before the configure block runs and configure/build/install commands will be run
+      # in the build dir.
+      #
+      # @example
+      #   pkg.build_dir "build"
+      #   pkg.source "my-cmake-project" # Will create the path "my-cmake-project/build"
+      #   pkg.configure { ["cmake .."] }
+      #   pkg.build { ["make -j 3"] }
+      #   pkg.install { ["make install"] }
+      #
+      # @param path [String] The build directory to use for building the project
+      def build_dir(path)
+        if Pathname.new(path).relative?
+          @component.build_dir = path
+        else
+          raise Vanagon::Error, "build_dir should be a relative path, but '#{path}' looks to be absolute."
+        end
+      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

data/lib/vanagon/component/rules.rb

@@ -0,0 +1,217 @@
+require 'vanagon/component'
+require 'vanagon/utilities/shell_utilities'
+require 'makefile'
+
+class Vanagon
+  class Component
+    # Vanagon::Component::Rules creates all Makefile rules for a given component.
+    class Rules
+
+      include Vanagon::Utilities::ShellUtilities
+
+      # Create methods that generate Makefile rules.
+      #
+      # This method cuts out some of the boilerplate of creating Makefile rules
+      # by creating methods and Makefile objects with a common name.
+      #
+      # @param target [Symbol] The rule target name.
+      # @param dependencies [Array<String>] An optional list of dependencies for the rule
+      # @yieldparam rule [Makefile::Rule] The generated Makefile rule
+      # @return [void]
+      #
+      # @!macro [attach] rule
+      #   @return [Makefile::Rule] The $1 rule
+      def self.rule(target, dependencies: [], &block)
+        define_method("#{target}_rule") do
+          Makefile::Rule.new("#{@component.name}-#{target}", dependencies: dependencies) do |rule|
+            instance_exec(rule, &block)
+          end
+        end
+      end
+
+      # @param component [Vanagon::Component] The component to create rules for.
+      # @param project [Vanagon::Project] The project associated with the component.
+      # @param platform [Vanagon::Platform] The platform where this component will be built.
+      def initialize(component, project, platform)
+        @component = component
+        @project = project
+        @platform = platform
+      end
+
+      # Generate all Makefile rules for this component.
+      #
+      # If the project has the cleanup attribute set, a cleanup rule will be included
+      # in the returned rules.
+      #
+      # @return [Array<Makefile::Rule>]
+      def rules
+        list = [
+          component_rule,
+          unpack_rule,
+          patch_rule,
+          configure_rule,
+          build_rule,
+          check_rule,
+          install_rule,
+          clean_rule,
+          clobber_rule,
+        ]
+        if @project.cleanup
+          list << cleanup_rule
+        end
+
+        list
+      end
+
+      # Generate a top level rule to build this component.
+      #
+      # @return [Makefile::Rule]
+      def component_rule
+        Makefile::Rule.new("#{@component.name}", dependencies: ["#{@component.name}-install"])
+      end
+
+      # Unpack the source for this component. The unpacking behavior depends on
+      # the source type of the component.
+      #
+      # @see [Vanagon::Component::Source]
+      rule("unpack", dependencies: ['file-list-before-build']) do |r|
+        r.recipe << andand(@component.get_environment, @component.extract_with)
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Apply any patches for this component.
+      rule("patch") do |r|
+        r.dependencies = ["#{@component.name}-unpack"]
+
+        after_unpack_patches = @component.patches.select { |patch| patch.after == "unpack" }
+        unless after_unpack_patches.empty?
+          r.recipe << andand_multiline(
+            "cd #{@component.dirname}",
+            after_unpack_patches.map { |patch| patch.cmd(@platform) }
+          )
+        end
+
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Create a build directory for this component if an out of source tree build is specified,
+      # and any configure steps, if any.
+      rule("configure") do |r|
+        r.dependencies = ["#{@component.name}-patch"].concat(@project.list_component_dependencies(@component))
+
+        if @component.get_build_dir
+          r.recipe << "[ -d #{@component.get_build_dir} ] || mkdir -p #{@component.get_build_dir}"
+        end
+
+        unless @component.configure.empty?
+          r.recipe << andand_multiline(
+            "cd #{@component.get_build_dir}",
+            @component.get_environment,
+            @component.configure
+          )
+        end
+
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Build this component.
+      rule("build") do |r|
+        r.dependencies = ["#{@component.name}-configure"]
+
+        unless @component.build.empty?
+          r.recipe << andand_multiline(
+            "cd #{@component.get_build_dir}",
+            @component.get_environment,
+            @component.build
+          )
+        end
+
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Run tests for this component.
+      rule("check") do |r|
+        r.dependencies = ["#{@component.name}-build"]
+
+        unless @component.check.empty? || @project.settings[:skipcheck]
+          r.recipe << andand_multiline(
+            "cd #{@component.get_build_dir}",
+            @component.get_environment,
+            @component.check
+          )
+        end
+
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Install this component.
+      rule("install") do |r|
+        r.dependencies = ["#{@component.name}-check"]
+
+        unless @component.install.empty?
+          r.recipe << andand_multiline(
+            "cd #{@component.get_build_dir}",
+            @component.get_environment,
+            @component.install
+          )
+        end
+
+        after_install_patches = @component.patches.select { |patch| patch.after == "install" }
+        after_install_patches.each do |patch|
+          r.recipe << andand(
+            "cd #{patch.destination}",
+            patch.cmd(@platform),
+          )
+        end
+
+        r.recipe << "touch #{r.target}"
+      end
+
+      # Run any post-installation cleanup steps for this component.
+      #
+      # This component is only included by {#rules} if the associated project has
+      # the `cleanup` attribute set.
+      rule("cleanup") do |r|
+        r.dependencies = ["#{@component.name}-install"]
+        r.recipe = [@component.cleanup_source, "touch #{r.target}"]
+      end
+
+      # Clean up any files generated while building this project.
+      #
+      # This cleans up the project by invoking `make clean` and removing the touch files
+      # for the configure/build/install steps.
+      rule("clean") do |r|
+        r.recipe << andand(
+          "[ -d #{@component.get_build_dir} ]",
+          "cd #{@component.get_build_dir}",
+          "#{@platform[:make]} clean"
+        )
+
+        %w(configure build install).each do |type|
+          touchfile = "#{@component.name}-#{type}"
+          r.recipe << andand(
+            "[ -e #{touchfile} ]",
+            "rm #{touchfile}"
+          )
+        end
+      end
+
+      # Remove all files associated with this component.
+      rule("clobber") do |r|
+        r.dependencies = ["#{@component.name}-clean"]
+        r.recipe = [
+          andand("[ -d #{@component.dirname} ]", "rm -r #{@component.dirname}"),
+          andand("[ -e #{@component.name}-unpack ]", "rm #{@component.name}-unpack")
+        ]
+      end
+
+      # Generate a Makefile fragment that contains all of the rules for the component.
+      # @return [String]
+      def format
+        rules.map(&:to_s).join("\n")
+      end
+
+      alias to_s format
+    end
+  end
+end