omnibus-sonian 1.2.0.1

data/lib/omnibus/build_version.rb

@@ -0,0 +1,285 @@
+#
+# 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.
+#
+
+require 'time'
+require 'omnibus/util'
+
+module Omnibus
+
+  # Provides methods for generating Omnibus project build version
+  # strings automatically from Git repository information.
+  #
+  # @see Omnibus::Project#build_version
+  #
+  # @note Requires a Git repository
+  # @todo Add class method shortcuts for semver and git_describe
+  #   versions e.g., Omnibus::BuildVersion.semver.
+  # @todo Rename this class to reflect its absolute dependence on running in a
+  #   Git repository.
+  class BuildVersion
+    include Omnibus::Util
+
+    # Formatting string for the timestamp component of our SemVer build specifier.
+    #
+    # @see Omnibus::BuildVersion#semver
+    # @see Time#strftime
+    TIMESTAMP_FORMAT = "%Y%m%d%H%M%S"
+
+    # @deprecated Use {#semver} or {#git_describe} instead
+    def self.full
+      puts "#{self.name}.full is deprecated. Use #{self.name}.new.semver or #{self.name}.new.git_describe."
+      Omnibus::BuildVersion.new.git_describe
+    end
+
+    # Create a new BuildVersion
+    #
+    # @param [String] path      Path from which to read git version information
+    def initialize(path=Omnibus.root)
+      @path = path
+    end
+
+    # @!group Version Generator Methods
+
+    # Generate a {http://semver.org/ SemVer 2.0.0-rc.1 compliant}
+    # version string for an Omnibus project.
+    #
+    # This relies on the Omnibus project being a Git repository, as
+    # well as having tags named according to SemVer conventions
+    # (specifically, the `MAJOR.MINOR.PATCH-PRERELEASE` aspects)
+    #
+    # The specific format of the version string is:
+    #
+    #     MAJOR.MINOR.PATCH-PRERELEASE+TIMESTAMP.git.COMMITS_SINCE.GIT_SHA
+    #
+    # By default, a timestamp is incorporated into the build component
+    # of version string (see
+    # {Omnibus::BuildVersion::TIMESTAMP_FORMAT}).  This can be
+    # disabled by setting the environment variable
+    # `OMNIBUS_APPEND_TIMESTAMP` to a "falsey" value (e.g. "false",
+    # "f", "no", "n", "0")
+    #
+    # @example 11.0.0-alpha.1+20121218164140.git.207.694b062
+    # @return [String]
+    # @see #git_describe
+    # @todo Issue a warning or throw an exception if the tags of the
+    #   repository are not themselves SemVer-compliant?
+    # @todo Consider making the {#build_start_time} method public, as
+    #   its function influences how build timestamps are generated,
+    #   and can be influenced by users.
+    def semver
+      build_tag = version_tag
+
+      # PRERELEASE VERSION
+      if prerelease_version?
+        # ensure all dashes are dots per precedence rules (#12) in Semver
+        # 2.0.0-rc.1
+        prerelease = prerelease_tag.gsub("-", ".")
+        build_tag << "-" << prerelease
+      end
+
+      # BUILD VERSION
+      # Follows SemVer conventions and the build version begins with a '+'.
+      build_version_items = []
+
+      # By default we will append a timestamp to every build. This behavior can
+      # be overriden by setting the OMNIBUS_APPEND_TIMESTAMP environment
+      # variable to a 'falsey' value (ie false, f, no, n or 0).
+      #
+      # format: YYYYMMDDHHMMSS example: 20130131123345
+      build_version_items << build_start_time.strftime(TIMESTAMP_FORMAT) if append_timestamp?
+
+      # We'll append the git describe information unless we are sitting right
+      # on an annotated tag.
+      #
+      # format: git.COMMITS_SINCE_TAG.GIT_SHA example: git.207.694b062
+      unless commits_since_tag == 0
+        build_version_items << ["git", commits_since_tag, git_sha_tag].join(".")
+      end
+
+      unless build_version_items.empty?
+        build_tag << "+" << build_version_items.join(".")
+      end
+
+      build_tag
+    end
+
+    # Generates a version string by running
+    # {https://www.kernel.org/pub/software/scm/git/docs/git-describe.html
+    # git describe} in the root of the Omnibus project.
+    #
+    # Produces a version string of the format
+    #
+    #     MOST_RECENT_TAG-COMMITS_SINCE-gGIT_SHA
+    #
+    # @example
+    #  11.0.0-alpha.1-207-g694b062
+    # @return [String]
+    def git_describe
+      @git_describe ||= begin
+                          git_cmd = "git describe"
+                          cmd = shellout(git_cmd,
+                                         :live_stream => nil,
+                                         :cwd => @path)
+                          if cmd.exitstatus == 0
+                            cmd.stdout.chomp
+                          else
+                            msg =  "Could not extract version information from `git describe`. "
+                            msg << "Setting version to 0.0.0"
+                            puts msg
+                            "0.0.0"
+                          end
+                        end
+    end
+
+    # @!endgroup
+
+    # Note: The remaining methods could just as well be private
+
+    # Return a `MAJOR.MINOR.PATCH` version string, as extracted from
+    # {#git_describe}.
+    #
+    # Here are some illustrative examples:
+    #
+    #     1.2.7-208-ge908a52 -> 1.2.7
+    #     11.0.0-alpha-59-gf55b180 -> 11.0.0
+    #     11.0.0-alpha2 -> 11.0.0
+    #     10.16.2.rc.1 -> 10.16.2
+    #
+    # @return [String]
+    def version_tag
+      version_composition.join(".")
+    end
+
+    # Return a prerelease tag string (if it exists), as extracted from {#git_describe}.
+    #
+    # Here are some illustrative examples:
+    #
+    #     1.2.7-208-ge908a52 -> nil
+    #     11.0.0-alpha-59-gf55b180 -> alpha
+    #     11.0.0-alpha2 -> alpha2
+    #     10.16.2.rc.1 -> rc.1
+    #
+    # @return [String] if a pre-release tag was found
+    # @return [nil] if no pre-release tag was found
+    def prerelease_tag
+      prerelease_regex = if commits_since_tag > 0
+                           /^\d+\.\d+\.\d+(?:-|\.)([0-9A-Za-z.-]+)-\d+-g[0-9a-f]+$/
+                         else
+                           /^\d+\.\d+\.\d+(?:-|\.)([0-9A-Za-z.-]+)$/
+                         end
+      match = prerelease_regex.match(git_describe)
+      match ? match[1] : nil
+    end
+
+    # Extracts the 7-character truncated Git SHA1 from the output of {#git_describe}.
+    #
+    # Here are some illustrative examples:
+    #
+    #     1.2.7-208-ge908a52 -> e908a52
+    #     11.0.0-alpha-59-gf55b180 -> f55b180
+    #     11.0.0-alpha2 -> nil
+    #     10.16.2.rc.1 -> nil
+    #
+    # @return [String] the truncated SHA1
+    # @return [nil] if no SHA1 is present in the output of #{git_describe}
+    def git_sha_tag
+      sha_regexp = /g([0-9a-f]+)$/
+      match = sha_regexp.match(git_describe)
+      match ? match[1] : nil
+    end
+
+    # Extracts the number of commits since the most recent Git tag, as
+    # determined by {#git_describe}.
+    #
+    # Here are some illustrative examples:
+    #
+    #     1.2.7-208-ge908a52 -> 208
+    #     11.0.0-alpha-59-gf55b180 -> 59
+    #     11.0.0-alpha2 -> 0
+    #     10.16.2.rc.1 -> 0
+    #
+    # @return [Fixnum]
+    def commits_since_tag
+      commits_regexp = /^.*-(\d+)\-g[0-9a-f]+$/
+      match = commits_regexp.match(git_describe)
+      match ? match[1].to_i : 0
+    end
+
+    # @todo This method is never called in Omnibus.  Is this even used
+    #   (e.g., in the DSL files)?
+    def development_version?
+      patch = version_composition.last
+      patch.to_i.odd?
+    end
+
+    # Indicates whether the version represents a pre-release or not, as
+    # signalled by the presence of a pre-release tag in the version
+    # string.
+    #
+    # @return [Boolean]
+    # @see #prerelease_tag
+    def prerelease_version?
+      !!(prerelease_tag)
+    end
+
+    private
+
+    # We'll attempt to retrive the timestamp from the Jenkin's set BUILD_ID
+    # environment variable. This will ensure platform specfic packages for the
+    # same build will share the same timestamp.
+    def build_start_time
+      @build_start_time ||= begin
+                              if !ENV['BUILD_ID'].nil?
+                                begin
+                                  Time.strptime(ENV['BUILD_ID'], "%Y-%m-%d_%H-%M-%S")
+                                rescue ArgumentError
+                                  error_message =  "BUILD_ID environment variable "
+                                  error_message << "should be in YYYY-MM-DD_hh-mm-ss "
+                                  error_message << "format."
+                                  raise ArgumentError, error_message
+                                end
+                              else
+                                Time.now.utc
+                              end
+                            end
+    end
+
+    # Pulls out the major, minor, and patch components from the output
+    # of {#git_describe}.
+    #
+    # Relies on the most recent Git tag being SemVer compliant (i.e.,
+    # starting with a `MAJOR.MINOR.PATCH` string)
+    #
+    # @return [Array<(String, String, String)>]
+    #
+    # @todo Compute this once and store the result in an instance variable
+    def version_composition
+      version_regexp = /^(\d+)\.(\d+)\.(\d+)/
+      version_regexp.match(git_describe)[1..3]
+    end
+
+    def append_timestamp?
+      if ENV['OMNIBUS_APPEND_TIMESTAMP'] && (ENV['OMNIBUS_APPEND_TIMESTAMP'] =~ (/^(false|f|no|n|0)$/i))
+        false
+      elsif ENV['OMNIBUS_APPEND_TIMESTAMP'] && (ENV['OMNIBUS_APPEND_TIMESTAMP'] =~ (/^(true|t|yes|y|1)$/i))
+        true
+      else
+        Omnibus::Config.append_timestamp
+      end
+    end
+  end
+end

data/lib/omnibus/builder.rb

@@ -0,0 +1,328 @@
+#
+# 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.
+#
+
+require 'forwardable'
+require 'omnibus/exceptions'
+
+module Omnibus
+  class Builder
+
+    # Proxies method calls to either a Builder object or the Software that the
+    # builder belongs to. Provides compatibility with our DSL where we never
+    # yield objects to blocks and hopefully hides some of the confusion that
+    # can arise from instance_eval.
+    class DSLProxy
+      extend Forwardable
+
+      # @todo def_delegators :@builder, :patch, :command, :ruby, ...
+
+      def_delegator :@builder, :patch
+      def_delegator :@builder, :command
+      def_delegator :@builder, :ruby
+      def_delegator :@builder, :gem
+      def_delegator :@builder, :bundle
+      def_delegator :@builder, :rake
+      def_delegator :@builder, :block
+      def_delegator :@builder, :name
+
+      def initialize(builder, software)
+        @builder, @software = builder, software
+      end
+
+      def eval_block(&block)
+        instance_eval(&block)
+      end
+
+      def respond_to?(method)
+        super || @software.respond_to?(method)
+      end
+
+      def methods
+        super | @software.methods
+      end
+
+      def method_missing(method_name, *args, &block)
+        if @software.respond_to?(method_name)
+          @software.send(method_name, *args, &block)
+        else
+          super
+        end
+      end
+
+    end
+
+
+    # @todo code duplication with {Fetcher::ErrorReporter}
+    class ErrorReporter
+
+      # @todo fetcher isn't even used
+      def initialize(error, fetcher)
+        @error, @fetcher = error, fetcher
+      end
+
+      # @todo this isn't necessary
+      def e
+        @error
+      end
+
+      def explain(why)
+        $stderr.puts "* " * 40
+        $stderr.puts why
+        $stderr.puts "Exception:"
+        $stderr.puts indent("#{e.class}: #{e.message.strip}", 2)
+        Array(e.backtrace).each {|l| $stderr.puts indent(l, 4) }
+        $stderr.puts "* " * 40
+      end
+
+      private
+
+      def indent(string, n)
+        string.split("\n").map {|l| " ".rjust(n) << l }.join("\n")
+      end
+
+    end
+
+    # @todo Look at using Bundler.with_clean_env{ ... } instead
+    BUNDLER_BUSTER = {  "RUBYOPT"         => nil,
+                        "BUNDLE_BIN_PATH" => nil,
+                        "BUNDLE_GEMFILE"  => nil,
+                        "GEM_PATH"        => nil,
+                        "GEM_HOME"        => nil }
+
+    attr_reader :build_commands
+
+    def initialize(software, &block)
+      @software = software
+      @build_commands = []
+      @dsl_proxy = DSLProxy.new(self, software)
+      @dsl_proxy.eval_block(&block) if block_given?
+    end
+
+    def name
+      @software.name
+    end
+
+    def command(*args)
+      @build_commands << args
+    end
+
+    def patch(*args)
+      args = args.dup.pop
+
+      # we'll search for a patch file in the project root AND
+      # the omnibus-software gem
+      candidate_roots = [Omnibus.project_root]
+      candidate_roots << Omnibus.omnibus_software_root if Omnibus.omnibus_software_root
+
+      candidate_paths = candidate_roots.map do |root|
+        File.expand_path("#{root}/config/patches/#{name}/#{args[:source]}")
+      end
+
+      source = candidate_paths.find{|path| File.exists?(path) }
+
+      unless source
+        raise MissingPatch.new(args[:source], candidate_paths)
+      end
+
+      plevel = args[:plevel] || 1
+      if args[:target] 
+        target = File.expand_path("#{project_dir}/#{args[:target]}")
+        @build_commands << 
+         "cat #{source} | patch -p#{plevel} #{target}"
+      else
+        @build_commands << 
+         "patch -d #{project_dir} -p#{plevel} -i #{source}"
+      end
+    end
+
+    # @todo all these ruby commands (ruby, gem, bundle, rake) could
+    #   all be collapsed into a single underlying implementation, since
+    #   they all just differ on the executable being called
+    def ruby(*args)
+      @build_commands << bundle_bust(*prepend_cmd("#{install_dir}/embedded/bin/ruby", *args))
+    end
+
+    def gem(*args)
+      @build_commands << bundle_bust(*prepend_cmd("#{install_dir}/embedded/bin/gem", *args))
+    end
+
+    def bundle(*args)
+      @build_commands << bundle_bust(*prepend_cmd("#{install_dir}/embedded/bin/bundle", *args))
+    end
+
+    def rake(*args)
+      @build_commands << bundle_bust(*prepend_cmd("#{install_dir}/embedded/bin/rake", *args))
+    end
+
+    def block(&rb_block)
+      @build_commands << rb_block
+    end
+
+    def project_dir
+      @software.project_dir
+    end
+
+    def install_dir
+      @software.install_dir
+    end
+
+    def log(message)
+      puts "[builder:#{name}] #{message}"
+    end
+
+    def build
+      log "building #{name}"
+      time_it("#{name} build") do
+        @build_commands.each do |cmd|
+          execute(cmd)
+        end
+      end
+    end
+
+    def execute(cmd)
+      case cmd
+      when Proc
+        execute_proc(cmd)
+      else
+        execute_sh(cmd)
+      end
+    end
+
+    private
+
+    def execute_proc(cmd)
+      cmd.call
+    rescue Exception => e
+      # In Ruby 1.9, Procs have a #source_location method with file/line info.
+      # Too bad we can't use it :(
+      ErrorReporter.new(e, self).explain("Failed to build #{name} while running ruby block build step")
+      raise
+    end
+
+    def execute_sh(cmd)
+      retries ||= 0
+      shell = nil
+      cmd_args = Array(cmd)
+      options = {
+        :cwd => project_dir,
+        :timeout => 5400
+      }
+      options[:live_stream] = STDOUT if ENV['DEBUG']
+      if cmd_args.last.is_a? Hash
+        cmd_options = cmd_args.last
+        cmd_args[cmd_args.size - 1] = options.merge(cmd_options)
+      else
+        cmd_args << options
+      end
+
+      cmd_string = cmd_args[0..-2].join(' ')
+      cmd_opts_for_display = to_kv_str(cmd_args.last)
+
+      log "Executing: `#{cmd_string}` with #{cmd_opts_for_display}"
+
+      shell = Mixlib::ShellOut.new(*cmd)
+      shell.environment["HOME"] = "/tmp" unless ENV["HOME"]
+
+      cmd_name = cmd_string.split(/\s+/).first
+      time_it("#{cmd_name} command") do
+        shell.run_command
+        shell.error!
+      end
+    rescue Exception => e
+      # Getting lots of errors from github, particularly with erlang/rebar
+      # projects fetching tons of deps via git all the time. This isn't a
+      # particularly elegant way to solve that problem. But it should work.
+      if retries >= 3
+        ErrorReporter.new(e, self).explain("Failed to build #{name} while running `#{cmd_string}` with #{cmd_opts_for_display}")
+        raise
+      else
+        time_to_sleep = 5 * (2 ** retries)
+        retries +=1
+        log "Failed to execute cmd #{cmd} #{retries} time(s). Retrying in #{time_to_sleep}s."
+        sleep(time_to_sleep)
+        retry
+      end
+    end
+
+    def prepend_cmd(str, *cmd_args)
+      if cmd_args.size == 1
+        # command as a string, no opts
+        "#{str} #{cmd_args.first}"
+      elsif cmd_args.size == 2 && cmd_args.last.is_a?(Hash)
+        # command as a string w/ opts
+        ["#{str} #{cmd_args.first}", cmd_args.last]
+      elsif cmd_args.size == 0
+        raise ArgumentError, "I don't even"
+      else
+        # cmd given as argv array
+        cmd_args.dup.unshift(str)
+      end
+    end
+
+    def bundle_bust(*cmd_args)
+      if cmd_args.last.is_a?(Hash)
+        cmd_args = cmd_args.dup
+        cmd_opts = cmd_args.pop.dup
+        cmd_opts[:env] = cmd_opts[:env] ? BUNDLER_BUSTER.merge(cmd_opts[:env]) : BUNDLER_BUSTER
+        cmd_args << cmd_opts
+      else
+        cmd_args << {:env => BUNDLER_BUSTER}
+      end
+    end
+
+
+    def time_it(what)
+      start = Time.now
+      yield
+    rescue Exception
+      elapsed = Time.now - start
+      log "#{what} failed, #{elapsed.to_f}s"
+      raise
+    else
+      elapsed = Time.now - start
+      log "#{what} succeeded, #{elapsed.to_f}s"
+    end
+
+    # Convert a hash to a string in the form `key=value`. It should work with
+    # whatever input is given but is designed to make the options to ShellOut
+    # look nice.
+    def to_kv_str(hash, join_str=",")
+      hash.inject([]) do |kv_pair_strs, (k,v)|
+        val_str = case v
+        when Hash
+          %Q["#{to_kv_str(v, " ")}"]
+        else
+          v.to_s
+        end
+        kv_pair_strs << "#{k}=#{val_str}"
+      end.join(join_str)
+    end
+
+  end
+
+  # @todo What's the point of this class?  Can we not just detect that
+  #   there are no commands in {Omnibus::Builder#build} and output the
+  #   appropriate message?  Seems like a lot of extra ceremony.
+  class NullBuilder < Builder
+
+    def build
+      log "Nothing to build for #{name}"
+    end
+
+  end
+
+end