omnibus 1.0.3 → 1.0.4

data/lib/omnibus/library.rb

@@ -20,17 +20,19 @@ module Omnibus
   # Used to generate the manifest of all software components with versions
   class Library
 
-    def initialize
-      @projects = []
+    attr_reader :components
+
+    def initialize(project)
       @components = []
+      @project = project
     end
 
     def component_added(component)
       @components << component
     end
 
-    def version_map(project)
-      @components.select {|c| c.project == project}.inject({}) {|map, component|
+    def version_map
+      @components.inject({}) {|map, component|
         map[component.name] = if component.given_version
                                 {:version       => component.version,
                                  :given_version => component.given_version,
@@ -41,9 +43,9 @@ module Omnibus
                                 ## pieces of the omnibus project
                                 ## itself, and so don't really fit
                                 ## with the concept of overrides
-                                v = {:version => project.build_version}
-                                if project.build_version.respond_to?(:git_sha)
-                                  v[:version_guid] = "git:#{project.build_version.git_sha}"
+                                v = {:version => @project.build_version}
+                                if @project.build_version.respond_to?(:git_sha)
+                                  v[:version_guid] = "git:#{@project.build_version.git_sha}"
                                 end
                                 v
                               end
@@ -54,16 +56,6 @@ module Omnibus
     def select(*args, &block)
       @components.select(*args, &block)
     end
-
-
-  end
-
-  def self.library
-    @library ||= Library.new
-  end
-
-  def self.component_added(*args)
-    library.component_added(*args)
   end
 
 end

data/lib/omnibus/package_release.rb

@@ -0,0 +1,163 @@
+#
+# Copyright:: Copyright (c) 2012 Opscode, Inc.
+# License:: Apache License, Version 2.0
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+# internal
+require 'omnibus/exceptions'
+
+# stdlib
+require 'json'
+
+# external
+require 'uber-s3'
+
+module Omnibus
+  class PackageRelease
+
+    attr_reader :package_path
+    attr_reader :access_policy
+
+    # @param package_path [String] file system path to the package artifact
+    # @option opts [:private, :public_read] :access specifies access control on
+    #   uploaded files
+    # @yield callback triggered by successful upload. Allows users of this
+    #   class to add UI feedback.
+    # @yieldparam s3_object_key [String] the S3 key of the uploaded object.
+    def initialize(package_path, opts={:access=>:private}, &block)
+      @package_path = package_path
+      @metadata = nil
+      @s3_client = nil
+
+      @after_upload = if block_given?
+        block
+      else
+        lambda { |item_key| nil }
+      end
+
+      # sets @access_policy
+      handle_opts(opts)
+    end
+
+    # Primary API for this class. Validates S3 configuration and package files,
+    # then runs the upload.
+    # @return [void]
+    # @raise [NoPackageFile, NoPackageMetadataFile] when the package or
+    #   associated metadata file do not exist.
+    # @raise [InvalidS3ReleaseConfiguration] when the Omnibus configuration is
+    #   missing required settings.
+    # @raise Also may raise errors from uber-s3 or net/http.
+    def release
+      validate_config!
+      validate_package!
+      s3_client.store(metadata_key, metadata_json, :access => access_policy)
+      uploaded(metadata_key)
+      s3_client.store(package_key, package_content, :access => access_policy, :content_md5 => md5)
+      uploaded(package_key)
+    end
+
+    def uploaded(key)
+      @after_upload.call(key)
+    end
+
+    def package_key
+      File.join(platform_path, File.basename(package_path))
+    end
+
+    def metadata_key
+      File.join(platform_path, File.basename(package_metadata_path))
+    end
+
+    def platform_path
+      File.join(metadata["platform"], metadata["platform_version"], metadata["arch"])
+    end
+
+    def md5
+      metadata["md5"]
+    end
+
+    def metadata
+      @metadata ||= JSON.parse(metadata_json)
+    end
+
+    def metadata_json
+      IO.read(package_metadata_path)
+    end
+
+    def package_content
+      IO.read(package_path)
+    end
+
+    def package_metadata_path
+      "#{package_path}.metadata.json"
+    end
+
+    def validate_package!
+      if !File.exist?(package_path)
+        raise NoPackageFile.new(package_path)
+      elsif !File.exist?(package_metadata_path)
+        raise NoPackageMetadataFile.new(package_metadata_path)
+      else
+        true
+      end
+    end
+
+    def validate_config!
+      if s3_access_key && s3_secret_key && s3_bucket
+        true
+      else
+        err = InvalidS3ReleaseConfiguration.new(s3_bucket, s3_access_key, s3_secret_key)
+        raise err
+      end
+    end
+
+    def s3_client
+      @s3_client ||= UberS3.new(
+        :access_key => s3_access_key,
+        :secret_access_key => s3_secret_key,
+        :bucket => s3_bucket,
+        :adaper => :net_http
+      )
+    end
+
+    def s3_access_key
+      config[:release_s3_access_key]
+    end
+
+    def s3_secret_key
+      config[:release_s3_secret_key]
+    end
+
+    def s3_bucket
+      config[:release_s3_bucket]
+    end
+
+    def config
+      Omnibus.config
+    end
+
+    def handle_opts(opts)
+      access_policy = opts[:access]
+      if access_policy.nil?
+        raise ArgumentError, "options to #{self.class} must specify `:access' (given: #{opts.inspect})"
+      elsif not [:private, :public_read].include?(access_policy)
+        raise ArgumentError, "option `:access' must be one of `[:private, :public_read]' (given: #{access_policy.inspect})"
+      else
+        @access_policy = access_policy
+      end
+    end
+
+  end
+end

data/lib/omnibus/project.rb

@@ -14,7 +14,10 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
+require 'omnibus/artifact'
 require 'omnibus/exceptions'
+require 'omnibus/library'
+require 'omnibus/util'
 
 module Omnibus
 
@@ -28,10 +31,12 @@ module Omnibus
   # @todo: Generate the DSL methods via metaprogramming... they're all so similar
   class Project
     include Rake::DSL
+    include Util
 
-    # @todo Why not just use `nil`?
     NULL_ARG = Object.new
 
+    attr_reader :library
+
     # Convenience method to initialize a Project from a DSL file.
     #
     # @param filename [String] the filename of the Project DSL file to load.
@@ -39,7 +44,6 @@ module Omnibus
       new(IO.read(filename), filename)
     end
 
-
     # Create a new Project from the contents of a DSL file.  Prefer
     # calling {Omnibus::Project#load} instead of using this method
     # directly.
@@ -51,12 +55,22 @@ module Omnibus
     #
     # @todo Remove filename parameter, as it is unused.
     def initialize(io, filename)
+      @output_package = nil
+      @name = nil
+      @package_name = nil
+      @install_path = nil
+      @homepage = nil
+      @description = nil
+      @replaces = nil
+
       @exclusions = Array.new
       @conflicts = Array.new
       @dependencies = Array.new
       @runtime_dependencies = Array.new
       instance_eval(io)
       validate
+
+      @library = Omnibus::Library.new(self)
       render_tasks
     end
 
@@ -381,7 +395,7 @@ module Omnibus
     def dependency?(software)
       name = if software.respond_to?(:name)
                software.send(:name)
-             elsif
+             else
                software
              end
       @dependencies.include?(name)
@@ -391,6 +405,66 @@ module Omnibus
 
     private
 
+    # An Array of platform data suitable for `Artifact.new`. This will go into
+    # metadata generated for the artifact, and be used for the file hierarchy
+    # of released packages if the default release scripts are used.
+    # @return [Array<String>] platform_shortname, platform_version_for_package,
+    #   machine architecture.
+    def platform_tuple
+      [platform_shortname, platform_version_for_package, machine]
+    end
+
+    # Platform version to be used in package metadata. For rhel, the minor
+    # version is removed, e.g., "5.6" becomes "5". For all other platforms,
+    # this is just the platform_version.
+    # @return [String] the platform version
+    def platform_version_for_package
+      if platform == "rhel"
+        platform_version[/([\d]+)\..+/, 1]
+      else
+        platform_version
+      end
+    end
+
+    # Platform name to be used when creating metadata for the artifact.
+    # rhel/centos become "el", all others are just platform
+    # @return [String] the platform family short name
+    def platform_shortname
+      if platform_family == "rhel"
+        "el"
+      else
+        platform
+      end
+    end
+
+    def render_metadata(pkg_type)
+      basename = output_package(pkg_type)
+      pkg_path = "#{config.package_dir}/#{basename}"
+      artifact = Artifact.new(pkg_path, [ platform_tuple ], :version => build_version)
+      metadata = artifact.flat_metadata
+      File.open("#{pkg_path}.metadata.json", "w+") do |f|
+        f.print(JSON.pretty_generate(metadata))
+      end
+    end
+
+    # The basename of the resulting package file.
+    # @return [String] the basename of the package file
+    def output_package(pkg_type)
+      case pkg_type
+      when "makeself"
+        "#{package_name}-#{build_version}_#{iteration}.sh"
+      when "msi"
+        "#{package_name}-#{build_version}-#{iteration}.msi"
+      else # fpm
+        require "fpm/package/#{pkg_type}"
+        pkg = FPM::Package.types[pkg_type].new
+        pkg.version = build_version
+        pkg.name = package_name
+        pkg.iteration = iteration
+        pkg.to_s
+      end
+    end
+
     # The command to generate an MSI package on Windows platforms.
     #
     # Does not execute the command, only assembles it.
@@ -411,7 +485,7 @@ module Omnibus
                      "-loc #{install_path}\\msi-tmp\\#{package_name}-en-us.wxl",
                      "#{install_path}\\msi-tmp\\#{package_name}-Files.wixobj",
                      "#{install_path}\\msi-tmp\\#{package_name}.wixobj",
-                     "-out #{config.package_dir}\\#{package_name}-#{build_version}-#{iteration}.msi"]
+                     "-out #{config.package_dir}\\#{output_package("msi")}"]
 
       # Don't care about the 204 return code from light.exe since it's
       # about some expected warnings...
@@ -438,8 +512,8 @@ module Omnibus
                           "-t #{pkg_type}",
                           "-v #{build_version}",
                           "-n #{package_name}",
+                          "-p #{output_package(pkg_type)}",
                           "--iteration #{iteration}",
-                          install_path,
                           "-m '#{maintainer}'",
                           "--description '#{description}'",
                           "--url #{homepage}"]
@@ -468,6 +542,7 @@ module Omnibus
       end
 
       command_and_opts << " --replaces #{@replaces}" if @replaces
+      command_and_opts << install_path
       command_and_opts
     end
 
@@ -476,13 +551,63 @@ module Omnibus
       command_and_opts = [ File.expand_path(File.join(Omnibus.source_root, "bin", "makeself.sh")),
                            "--gzip",
                            install_path,
-                           "#{package_name}-#{build_version}_#{iteration}.sh",
+                           output_package("makeself"),
                            "'The full stack of #{@name}'"
                          ]
       command_and_opts << "./makeselfinst" if File.exists?("#{package_scripts_path}/makeselfinst")
       command_and_opts
     end
 
+    # Runs the makeself commands to make a self extracting archive package.
+    # As a (necessary) side-effect, sets
+    # @return void
+    def run_makeself
+      package_commands = []
+      # copy the makeself installer into package
+      if File.exists?("#{package_scripts_path}/makeselfinst")
+        package_commands << "cp #{package_scripts_path}/makeselfinst #{install_path}/"
+      end
+
+      # run the makeself program
+      package_commands << makeself_command.join(" ")
+
+      # rm the makeself installer (for incremental builds)
+      package_commands << "rm -f #{install_path}/makeselfinst"
+      package_commands.each {|cmd| run_package_command(cmd) }
+    end
+
+    # Runs the necessary command to make an MSI. As a side-effect, sets `output_package`
+    # @return void
+    def run_msi
+      run_package_command(msi_command)
+    end
+
+    # Runs the necessary command to make a package with fpm. As a side-effect,
+    # sets `output_package`
+    # @return void
+    def run_fpm(pkg_type)
+      run_package_command(fpm_command(pkg_type).join(" "))
+    end
+
+    # Executes the given command via mixlib-shellout.
+    # @return [Mixlib::ShellOut] returns the underlying Mixlib::ShellOut
+    #   object, so the caller can inspect the stdout and stderr.
+    def run_package_command(cmd)
+      cmd_options = {
+        :timeout => 3600,
+        :cwd => config.package_dir
+      }
+
+      if cmd.is_a?(Array)
+        command = cmd[0]
+        cmd_options.merge!(cmd[1])
+      else
+        command = cmd
+      end
+
+      shellout!(command, cmd_options)
+    end
+
     # Dynamically generate Rake tasks to build projects and all the software they depend on.
     #
     # @note Much Rake magic ahead!
@@ -493,81 +618,52 @@ module Omnibus
       directory "pkg"
 
       namespace :projects do
+        namespace @name do
 
-        package_types.each do |pkg_type|
-          namespace @name do
-            desc "package #{@name} into a #{pkg_type}"
-            task pkg_type => (@dependencies.map {|dep| "software:#{dep}"}) do
+          package_types.each do |pkg_type|
+            dep_tasks = @dependencies.map {|dep| "software:#{dep}"}
+            dep_tasks << config.package_dir
+            dep_tasks << "health_check"
 
-              package_commands = []
+            desc "package #{@name} into a #{pkg_type}"
+            task pkg_type => dep_tasks do
               if pkg_type == "makeself"
-                # copy the makeself installer into package
-                if File.exists?("#{package_scripts_path}/makeselfinst")
-                  package_commands << "cp #{package_scripts_path}/makeselfinst #{install_path}/"
-                end
-
-                # run the makeself program
-                package_commands << makeself_command.join(" ")
-
-                # rm the makeself installer (for incremental builds)
-                package_commands << "rm -f #{install_path}/makeselfinst"
+                run_makeself
               elsif pkg_type == "msi"
-                package_commands <<  msi_command
+                run_msi
               else # pkg_type == "fpm"
-                package_commands <<  fpm_command(pkg_type).join(" ")
+                run_fpm(pkg_type)
               end
 
-              # run the commands
-              package_commands.each do |cmd|
-                cmd_options = {
-                  :live_stream => STDOUT,
-                  :timeout => 3600,
-                  :cwd => config.package_dir
-                }
-
-                if cmd.is_a?(Array)
-                  command = cmd[0]
-                  cmd_options.merge!(cmd[1])
-                else
-                  command = cmd
-                end
-
-                shell = Mixlib::ShellOut.new(command, cmd_options)
-                shell.run_command
-                shell.error!
-              end
-            end
+              render_metadata(pkg_type)
 
-            # TODO: why aren't these dependencies just added in at the
-            # initial creation of the 'pkg_type' task?
-            task pkg_type => config.package_dir
-            task pkg_type => "#{@name}:health_check"
+            end
           end
-        end
 
-        task "#{@name}:copy" => (package_types.map {|pkg_type| "#{@name}:#{pkg_type}"}) do
-          if OHAI.platform == "windows"
-            cp_cmd = "xcopy #{config.package_dir}\\*.msi pkg\\ /Y"
-          else
-            cp_cmd = "cp #{config.package_dir}/* pkg/"
+          task "copy" => package_types do
+            if OHAI.platform == "windows"
+              cp_cmd = "xcopy #{config.package_dir}\\*.msi pkg\\ /Y"
+            else
+              cp_cmd = "cp #{config.package_dir}/* pkg/"
+            end
+            shell = Mixlib::ShellOut.new(cp_cmd)
+            shell.run_command
+            shell.error!
+          end
+          task "copy" => "pkg"
+
+          desc "run the health check on the #{@name} install path"
+          task "health_check" do
+            if OHAI.platform == "windows"
+              puts "Skipping health check on windows..."
+            else
+              Omnibus::HealthCheck.run(install_path)
+            end
           end
-          shell = Mixlib::ShellOut.new(cp_cmd)
-          shell.run_command
-          shell.error!
         end
-        task "#{@name}:copy" => "pkg"
 
         desc "package #{@name}"
         task @name => "#{@name}:copy"
-
-        desc "run the health check on the #{@name} install path"
-        task "#{@name}:health_check" do
-          if OHAI.platform == "windows"
-            puts "Skipping health check on windows..."
-          else
-            Omnibus::HealthCheck.run(install_path)
-          end
-        end
       end
     end
   end