mattock 0.4.1 → 0.5.0

data/lib/mattock/command-line.rb

@@ -1,47 +1,6 @@
-module Mattock
-  class CommandRunResult
-    def initialize(command, status, streams)
-      @command = command
-      @process_status = status
-      @streams = streams
-    end
-    attr_reader :process_status, :streams
-
-    def stdout
-      @streams[1]
-    end
-
-    def stderr
-      @streams[2]
-    end
-
-    def exit_code
-      @process_status.exitstatus
-    end
-    alias exit_status exit_code
-
-    def succeeded?
-      must_succeed!
-      return true
-    rescue
-      return false
-    end
-
-    def format_streams
-      "stdout:#{stdout.nil? || stdout.empty? ? "[empty]\n" : "\n#{stdout}"}" +
-      "stderr:#{stderr.nil? || stderr.empty? ? "[empty]\n" : "\n#{stderr}"}---"
-    end
-
-    def must_succeed!
-      case exit_code
-      when 0
-        return exit_code
-      else
-        fail "Command #{@command.inspect} failed with exit status #{exit_code}: \n#{format_streams}"
-      end
-    end
-  end
+require 'mattock/command-line/command-run-result'
 
+module Mattock
   class CommandLine
     def self.define_chain_op(opname, klass)
       define_method(opname) do |other|
@@ -76,6 +35,11 @@ module Mattock
 
     alias_method :command_environment, :env
 
+    def set_env(name, value)
+      command_environment[name] = value
+      return self
+    end
+
     def verbose
       ::Rake.verbose && ::Rake.verbose != ::Rake::FileUtilsExt::DEFAULT
     end
@@ -122,6 +86,12 @@ module Mattock
       redirect_from(path, 0)
     end
 
+    def replace_us
+      puts "Ceding execution to: "
+      puts string_format
+      Process.exec(command_environment, command)
+    end
+
     def spawn_process
       host_stdout, cmd_stdout = IO.pipe
       host_stderr, cmd_stderr = IO.pipe
@@ -134,35 +104,12 @@ module Mattock
     end
 
     def collect_result(pid, host_stdout, host_stderr)
-      pid, status = Process.wait2(pid)
-
-      stdout = consume_buffer(host_stdout)
-      stderr = consume_buffer(host_stderr)
-      result = CommandRunResult.new(command, status, {1 => stdout, 2 => stderr})
-      host_stdout.close
-      host_stderr.close
-
+      result = CommandRunResult.new(pid, self)
+      result.streams = {1 => host_stdout, 2 => host_stderr}
+      result.wait
       return result
     end
 
-    #Gets all the data out of buffer, even if somehow it doesn't have an EOF
-    #Escpecially useful for programs (e.g. ssh) that sometime set their stderr
-    #to O_NONBLOCK
-    def consume_buffer(io)
-      accumulate = []
-      waits = 3
-      begin
-        while chunk = io.read_nonblock(4096)
-          accumulate << chunk
-        end
-      rescue IO::WaitReadable => ex
-        retry if (waits -= 1) > 0
-      end
-      return accumulate.join
-    rescue EOFError
-      return accumulate.join
-    end
-
     #If I wasn't worried about writing my own limited shell, I'd say e.g.
     #Pipeline would be an explicit chain of pipes... which is probably as
     #originally intended :/

data/lib/mattock/command-line/command-run-result.rb

@@ -0,0 +1,131 @@
+module Mattock
+  class CommandLine
+    class CommandRunResult
+      def initialize(pid, command)
+        @command = command
+        @pid = pid
+
+        #####
+        @process_status = nil
+        @streams = {}
+        @consume_timeout = nil
+      end
+      attr_reader :process_status, :pid
+      attr_accessor :consume_timeout, :streams
+
+      def stdout
+        @streams[1]
+      end
+
+      def stderr
+        @streams[2]
+      end
+
+      def exit_code
+        @process_status.exitstatus
+      end
+      alias exit_status exit_code
+
+      def succeeded?
+        must_succeed!
+        return true
+      rescue
+        return false
+      end
+
+      def format_streams
+        "stdout:#{stdout.nil? || stdout.empty? ? "[empty]\n" : "\n#{stdout}"}" +
+        "stderr:#{stderr.nil? || stderr.empty? ? "[empty]\n" : "\n#{stderr}"}---"
+      end
+
+      def must_succeed!
+        case exit_code
+        when 0
+          return exit_code
+        else
+          fail "Command #{@command.inspect} failed with exit status #{exit_code}: \n#{format_streams}"
+        end
+      end
+
+      def wait
+        @accumulators = {}
+        waits = {}
+        @buffered_echo = []
+
+        ioes = streams.values
+        ioes.each do |io|
+          @accumulators[io] = []
+          waits[io] = 3
+        end
+        begin_echoing = Time.now + (@consume_timeout || 3)
+
+        @live_ioes = ioes.dup
+
+        until @live_ioes.empty? do
+          newpid, @process_status = Process.waitpid2(pid, Process::WNOHANG)
+
+          unless @process_status.nil?
+            consume_buffers(@live_ioes)
+            break
+          end
+
+          timeout = 0
+
+          if !@buffered_echo.nil?
+            timeout = begin_echoing - Time.now
+            if timeout < 0
+              puts
+              puts "Long running command output:"
+              puts @buffered_echo.join
+              @buffered_echo = nil
+            end
+          end
+
+          if timeout > 0
+            result = IO::select(@live_ioes, [], @live_ioes, timeout)
+          else
+            result = IO::select(@live_ioes, [], @live_ioes, 1)
+          end
+
+          unless result.nil? #timeout
+            readable, _writeable, errored = *result
+            unless errored.empty?
+              raise "Error on IO: #{errored.inspect}"
+            end
+
+            consume_buffers(readable)
+          end
+        end
+
+        if @process_status.nil?
+          newpid, @process_status = Process.waitpid2(pid)
+        end
+
+        ioes.each do |io|
+          io.close
+        end
+        @streams = Hash[ioes.each_with_index.map{|io, index| [index + 1, @accumulators[io].join]}]
+      end
+
+      def consume_buffers(readable)
+        if not(readable.nil? or readable.empty?)
+          readable.each do |io|
+            begin
+              while chunk = io.read_nonblock(4096)
+                if @buffered_echo.nil?
+                  puts chunk
+                else
+                  @buffered_echo << chunk
+                end
+                @accumulators[io] <<  chunk
+              end
+            rescue IO::WaitReadable => ex
+            rescue EOFError => ex
+              @live_ioes.delete(io)
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mattock/command-task.rb

@@ -43,12 +43,16 @@ module Mattock
       decorated(command).must_succeed!
     end
 
+    def check_verification_command
+      !decorated(verify_command).succeeds?
+    end
+
     def needed?
       finalize_configuration
       if verify_command.nil?
         super
       else
-        !decorated(verify_command).succeeds?
+        check_verification_command
       end
     end
   end

data/lib/mattock/configurable.rb

@@ -1,5 +1,5 @@
 module Mattock
-  #Handles setting options on objects its mixed into
+  #Handles setting options on objects it's mixed into
   #
   #Settings can have default values or be required (as opposed to defaulting to
   #nil).  Settings and their defaults are inherited (and can be overridden) by
@@ -18,550 +18,12 @@ module Mattock
         super("No default value for field #{field_name} on class #{klass.name}")
       end
     end
-
-    class FieldMetadata
-      attr_accessor :name, :default_value
-
-      DEFAULT_PROPERTIES = {
-        :copiable => true,
-        :proxiable => true,
-        :required => false,
-        :runtime => false,
-        :defaulting => true,
-      }
-      def initialize(name, value)
-        @name = name
-        @default_value = value
-        @properties = DEFAULT_PROPERTIES.clone
-      end
-
-      def inspect
-        set_props = DEFAULT_PROPERTIES.keys.find_all do |prop|
-          @properties[prop]
-        end
-        "Field: #{name}: #{default_value.inspect} #{set_props.inspect}"
-      end
-
-      def validate_property_name(name)
-        unless DEFAULT_PROPERTIES.has_key?(name)
-          raise "Invalid field property #{name.inspect} - valid are: #{DEFAULT_PROPERTIES.keys.inspect}"
-        end
-      end
-
-      def is?(property)
-        validate_property_name(property)
-        @properties[property]
-      end
-
-      def is_not?(property)
-        validate_property_name(property)
-        !@properties[property]
-      end
-      alias isnt? is_not?
-
-      def is(property)
-        validate_property_name(property)
-        @properties[property] = true
-        self
-      end
-
-      def is_not(property)
-        validate_property_name(property)
-        @properties[property] = false
-        self
-      end
-      alias isnt is_not
-
-      def ivar_name
-        "@#{name}"
-      end
-
-      def writer_method
-        "#{name}="
-      end
-
-      def reader_method
-        name
-      end
-
-      def immediate_value_on(instance)
-        instance.instance_variable_get(ivar_name)
-      end
-
-      def value_on(instance)
-        value = immediate_value_on(instance)
-        if ProxyValue === value
-          value.field.value_on(value.source)
-        else
-          value
-        end
-      end
-
-      def set_on?(instance)
-        return false unless instance.instance_variable_defined?(ivar_name)
-        value = immediate_value_on(instance)
-        if name == :destination_path
-        end
-        if ProxyValue === value
-          value.field.set_on?(value.source)
-        else
-          true
-        end
-      end
-
-      def unset_on?(instance)
-        !set_on?(instance)
-      end
-
-      def missing_on?(instance)
-        return false unless is?(:required)
-        if instance.respond_to?(:runtime?) and !instance.runtime?
-          return runtime_missing_on?(instance)
-        else
-          return !set_on?(instance)
-        end
-      end
-
-      def runtime_missing_on?(instance)
-        return false if is?(:runtime)
-        return true unless instance.instance_variable_defined?(ivar_name)
-        value = immediate_value_on(instance)
-        if ProxyValue === value
-          value.field.runtime_missing_on?(value.source)
-        else
-          false
-        end
-      end
-    end
-
-    class ProxyValue
-      def initialize(source, field)
-        @source, @field = source, field
-      end
-      attr_reader :source, :field
-
-      def inspect
-        "#{self.class.name.split(':').last}: #{source.class.name}.#{field.inspect}"
-      end
-    end
-
-    class ProxyDecorator
-      def initialize(configurable)
-        @configurable = configurable
-      end
-
-      def method_missing(name, *args, &block)
-        super unless block.nil? and args.empty?
-        super unless @configurable.respond_to?(name)
-        return ProxyValue.new(@configurable, @configurable.class.field_metadata(name))
-      end
-    end
-
-    class FieldProcessor
-      def initialize(source)
-        @source = source
-        @field_names = filter(source.class.field_names)
-      end
-      attr_accessor :field_names
-      attr_reader :source
-
-      def filter_attribute
-        raise NotImplementedError
-      end
-
-      def filter(field_names)
-        field_names.find_all do |name|
-          source.class.field_metadata(name).is?(filter_attribute)
-        end
-      end
-
-      def value(field)
-        source.__send__(field.reader_method)
-      end
-
-      def to(target)
-        field_names.each do |name|
-          field = source.class.field_metadata(name)
-          next unless target.respond_to?(field.writer_method)
-          target.__send__(field.writer_method, value(field))
-        end
-      end
-    end
-
-    class SettingsCopier < FieldProcessor
-      def filter_attribute
-        :copiable
-      end
-
-      def value(field)
-        field.immediate_value_on(source)
-      end
-    end
-
-    class SettingsProxier < FieldProcessor
-      def filter_attribute
-        :proxiable
-      end
-
-      def value(field)
-        ProxyValue.new(source, field)
-      end
-    end
-
-    #Describes class level DSL & machinery for working with configuration
-    #managment.
-    #
-    #@example
-    #    class ConfExample
-    #      include Configurable
-    #
-    #      setting :foo
-    #      settings :bar => 1, :baz => 3
-    #      nil_fields :hoo, :ha, :harum
-    #      required_fields :must
-    #
-    #      def initialize
-    #        setup_defaults
-    #      end
-    #    end
-    #
-    #    ce = ConfExample.new
-    #    ce.bar #=> 1
-    #    ce.hoo #=> nil
-    #    ce.hoo = "hallo"
-    #    ce.check_required #=> raises error because :must and :foo aren't set
-    module ClassMethods
-      def inspect_instance(instance, indent="")
-        field_names.map do |name|
-          meta = field_metadata(name)
-          "#{indent}#{meta.inspect} => #{meta.immediate_value_on(instance).inspect}(#{meta.value_on(instance).inspect})"
-        end.join("\n")
-      end
-
-      def default_values
-        @default_values ||= []
-      end
-
-      def field_names
-        names = default_values.map{|field| field.name}
-        if Configurable > superclass
-          names | superclass.field_names
-        else
-          names
-        end
-      end
-
-      def field_metadata(name)
-        field = default_values.find{|field| field.name == name}
-        if field.nil? and Configurable > superclass
-          superclass.field_metadata(name)
-        else
-          field
-        end
-      end
-
-      #@raises NoDefaultValue
-      def default_value_for(name)
-        field = field_metadata(name)
-        raise NoDefaultValue.new(name,self) unless field.is?(:defaulting)
-        return field.default_value
-      end
-
-      #Creates an anonymous Configurable - useful in complex setups for nested
-      #settings
-      #@example SSH options
-      #  setting :ssh => nested(:username => "me", :password => nil)
-      def nested(hash=nil, &block)
-        nested = Class.new(Struct)
-        nested.settings(hash || {})
-        if block_given?
-          nested.instance_eval(&block)
-        end
-        return nested
-      end
-
-      #Quick list of setting fields with a default value of nil.  Useful
-      #especially with {CascadingDefinition#resolve_configuration}
-      def nil_fields(*names)
-        names.each do |name|
-          setting(name, nil)
-        end
-        self
-      end
-      alias nil_field nil_fields
-
-      #List fields with no default for with a value must be set before
-      #definition.
-      def required_fields(*names)
-        names.each do |name|
-          setting(name)
-        end
-        self
-      end
-      alias required_field required_fields
-
-      RequiredField = Object.new.freeze
-
-      #Defines a setting on this class - much like a attr_accessible call, but
-      #allows for defaults and required settings
-      def setting(name, default_value = RequiredField)
-        name = name.to_sym
-        metadata =
-          if default_value == RequiredField
-            FieldMetadata.new(name, nil).is(:required).isnt(:defaulting)
-          else
-            FieldMetadata.new(name, default_value)
-          end
-
-        attr_writer(name)
-        define_method(metadata.reader_method) do
-          value = metadata.value_on(self)
-        end
-
-        if existing = default_values.find{|field| field.name == name} and existing.default_value != default_value
-          source_line = caller.drop_while{|line| /#{__FILE__}/ =~ line}.first
-            warn "Changing default value of #{self.name}##{name} from #{existing.default_value.inspect} to #{default_value.inspect}"
-          "  (at: #{source_line})"
-        end
-        default_values << metadata
-        metadata
-      end
-
-      def runtime_required_fields(*names)
-        names.each do |name|
-          runtime_setting(name)
-        end
-        self
-      end
-      alias runtime_required_field runtime_required_fields
-
-      def runtime_setting(name, default_value = RequiredField)
-        setting(name, default_value).is(:runtime)
-      end
-
-      #@param [Hash] hash Pairs of name/value to be converted into
-      #  setting/default
-      def settings(hash)
-        hash.each_pair do |name, value|
-          setting(name, value)
-        end
-        return self
-      end
-      alias runtime_settings settings
-
-      def set_defaults_on(instance)
-        if Configurable > superclass
-          superclass.set_defaults_on(instance)
-        end
-        default_values.each do |field|
-          next unless field.is? :defaulting
-          value = field.default_value
-          if Module === value and Configurable > value
-            value = value.new
-            value.class.set_defaults_on(value)
-          end
-          instance.__send__(field.writer_method, value)
-        end
-      end
-
-      def missing_required_fields_on(instance)
-        missing = []
-        if Configurable > superclass
-          missing = superclass.missing_required_fields_on(instance)
-        end
-        default_values.each do |field|
-          if field.missing_on?(instance)
-            missing << field.name
-          else
-            set_value = instance.__send__(field.reader_method)
-            if Configurable === set_value
-              missing += set_value.class.missing_required_fields_on(set_value).map do |field|
-                [name, field].join(".")
-              end
-            end
-          end
-        end
-        return missing
-      end
-
-      def copy_settings(from, to, &block)
-        if Configurable > superclass
-          superclass.copy_settings(from, to, &block)
-        end
-        default_values.each do |field|
-          begin
-            value =
-              if block_given?
-                yield(from, field)
-              else
-                from.__send__(field.reader_method)
-              end
-            if Configurable === value
-              value = value.clone
-            end
-            to.__send__(field.writer_method, value)
-          rescue NoMethodError
-            #shrug it off
-          end
-        end
-      end
-
-      def to_hash(obj)
-        hash = if Configurable > superclass
-                 superclass.to_hash(obj)
-               else
-                 {}
-               end
-        hash.merge( Hash[default_values.map{|field|
-          begin
-            value = obj.__send__(field.reader_method)
-            value =
-              case value
-              when Configurable
-                value.to_hash
-              else
-                value
-              end
-            [field.name, value]
-          rescue NoMethodError
-          end
-        }])
-      end
-
-
-      def included(mod)
-        mod.extend ClassMethods
-      end
-    end
-
-    extend ClassMethods
-
-    module DirectoryStructure
-      module ClassMethods
-        RequiredField = ::Mattock::Configurable::ClassMethods::RequiredField
-
-        attr_accessor :path_heirarchy
-        attr_accessor :path_fields
-
-        def dir(field_name, *args)
-          rel_path = RequiredField
-          if String === args.first
-            rel_path = args.shift
-          end
-          parent_field = path(field_name, rel_path)
-          self.path_heirarchy += args.map do |child_field|
-            [parent_field, child_field]
-          end
-          return parent_field
-        end
-
-        def path(field_name, rel_path=RequiredField)
-          field = setting(field_name, nested{
-            required_field :absolute_path
-            setting :relative_path, rel_path
-          })
-          path_fields << field
-          return field
-        end
-      end
-
-      def self.included(sub)
-        sub.extend ClassMethods
-        sub.path_heirarchy = []
-        sub.path_fields = []
-      end
-
-      def resolve_paths
-        missing_relatives = []
-        self.class.path_heirarchy.reverse.each do |parent_field, child_field|
-          child = child_field.value_on(self)
-          next unless child.field_unset?(:absolute_path)
-          if child.field_unset?(:relative_path)
-            missing_relatives << child_field
-            next
-          end
-          parent = parent_field.value_on(self)
-          child.absolute_path = File::join(parent.absolute_path, child.relative_path)
-        end
-        unless missing_relatives.empty?
-          raise "Required field#{missing_relatives.length == 1 ? "" : "s"} #{missing_relatives.map{|field| "#{field.name}.relative_path".inspect}.join(", ")} unset on #{self.inspect}"
-        end
-        self.class.path_fields.each do |field|
-          value = field.value_on(self)
-          next unless value.field_unset?(:relative_path)
-          value.relative_path = value.absolute_path
-        end
-      end
-    end
-
-    def copy_settings
-      SettingsCopier.new(self)
-    end
-
-    def copy_settings_to(other)
-      copy_settings.to(other)
-      self
-    end
-
-    def proxy_settings
-      SettingsProxier.new(self)
-    end
-
-    def proxy_settings_to(other)
-      proxy_settings.to(other)
-    end
-
-    def to_hash
-      self.class.to_hash(self)
-    end
-
-    def unset_defaults_guard
-      raise "Tried to check required settings before running setup_defaults"
-    end
-
-    #Call during initialize to set default values on settings - if you're using
-    #Configurable outside of Mattock, be sure this gets called.
-    def setup_defaults
-      def self.unset_defaults_guard
-      end
-
-      self.class.set_defaults_on(self)
-      self
-    end
-
-    #Checks that all required fields have be set, otherwise raises an error
-    #@raise RuntimeError if any required fields are unset
-    def check_required
-      unset_defaults_guard
-      missing = self.class.missing_required_fields_on(self)
-      unless missing.empty?
-        raise "Required field#{missing.length > 1 ? "s" : ""} #{missing.map{|field| field.to_s.inspect}.join(", ")} unset on #{self.inspect}"
-      end
-      self
-    end
-
-    def proxy_value
-      ProxyDecorator.new(self)
-    end
-
-    #XXX deprecate
-    def unset?(value)
-      value.nil?
-    end
-
-    def field_unset?(name)
-      self.class.field_metadata(name).unset_on?(self)
-    end
-
-    def fail_unless_set(name)
-      if self.class.field_metadata(name).unset_on?(self)
-        raise "Assertion failed: Field #{name} unset"
-      end
-      true
-    end
-
-    class Struct
-      include Configurable
-    end
   end
 end
+
+require 'mattock/configurable/field-metadata'
+require 'mattock/configurable/proxy-value'
+require 'mattock/configurable/field-processor'
+require 'mattock/configurable/class-methods'
+require 'mattock/configurable/instance-methods'
+require 'mattock/configurable/directory-structure'