chef-resource 0.2.2

data/files/lib/chef_resource/output/nested_converge/open_resource.rb

@@ -0,0 +1,113 @@
+require 'highline/import'
+require 'set'
+
+module ChefResource
+  module Chef
+    module Output
+      class NestedConverge
+        class ResourceFormat
+          def initialize(output, resource)
+            @output = output
+            @resource = resource
+            @largest_child_prefix = 0
+            @parent = output.open_resources[resource]
+            @parent.add_child(self)
+          end
+
+          attr_reader :output
+          attr_reader :parent
+          attr_reader :resource
+          attr_reader :open_children
+          attr_accessor :largest_child_prefix
+          def open_children
+            @open_children ||= Hash.new
+          end
+          def indent
+            parent ? parent.indent + output.indent_step : 0
+          end
+
+          def add_child(resource)
+            if resource.prefix.length >
+              open_children << resource
+            end
+          end
+          def remove_child(child)
+            open_children.delete(child)
+          end
+
+          def resource_event(event, *args)
+            case event
+            when :identity_defined
+              print_line("Opened", output.style.opened)
+            when :fully_defined
+              print_line("Defined", output.style.defined)
+            when :updating
+              print_line("updating ...", output.style.updating)
+            when :updated
+              print_line(resource.description, output.style.updated)
+              print_line(resource.change_description, output.style.updated)
+              close
+            when :update_failed
+              print_line("Failed", output.style.update_failed)
+              close
+            when :unchanged
+              print_line("Unchanged", output.style.unchanged)
+              close
+            when :debug, :info, :warn, :error, :fatal
+              print_line(args[0], output.style.public_send(event))
+            when :stdout, :stderr
+              print_stream(event, args[0], output.style.public_send(event))
+            end
+          end
+
+          private
+
+          def close
+            parent.remove_child(self)
+            output.resource_closed(self)
+          end
+
+          def print_header
+            if output.current_resource != parent
+            end
+          end
+
+          def print_header_line(line, style)
+            if parallel_header?
+              while
+              end
+            end
+            if output.current_resource != parent
+              parent.print_header
+              parent.print_line("", output.style.updating)
+            end
+            output.print_line("#{line_prefix}#{line}", style)
+            output.current_resource = self
+          end
+
+          def print_line(str, style)
+            str.lines.each do |line|
+              output.take do |is_current|
+                if is_current
+                  output.print_line("#{empty_prefix}#{line}", style)
+                else
+                  print_header_line(line, style)
+                end
+              end
+            end
+          end
+
+          def print_stream(stream, str, style)
+            output.print(self, current, str, style)
+          end
+
+          def print_color(color, str)
+            str.lines.each do |line|
+              @out.print HighLine.color(line, *options[:colors])
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/output/region_stream.rb

@@ -0,0 +1,145 @@
+module ChefResource
+  module Chef
+    module Output
+      class RegionText
+
+      end
+
+      #
+      # A region of the screen.
+      #
+      class ScreenRegion
+        def initialize(parent)
+          @parent = parent
+          @width = 0
+          @height = 0
+        end
+
+        #
+        # The parent region
+        #
+        property :parent
+
+        #
+        # The top y coordinate of the region
+        #
+        property :top
+
+        #
+        # The left hand coordinate of the region
+        #
+        property :height
+
+        #
+        # The width of the region.
+        #
+        property :width
+
+        #
+        # The height of the region
+        #
+        property :height
+      end
+
+      #
+      # A list of regions
+      #
+      class ScreenRegionList < ScreenRegion
+        def regions
+          @regions ||= []
+        end
+        def add_region(region)
+          regions << region if !regions.include?(region)
+        end
+        def remove_region(region)
+          regions.delete(region)
+        end
+      end
+
+      #
+      # A horizontal list of regions
+      #
+      class HorizontalRegionList < ScreenRegionList
+      end
+
+      #
+      # A vertical list of regions
+      #
+      class VerticalRegionList
+      end
+
+      #
+      # A nested display like so:
+      #
+      # cookbook::recipe_name
+      # |-- Machine Batch: web
+      # |   |-- Machine web1
+      # |   |   |-- Node web1
+      # |   |   |   |-- Property apache2.port changed from 80 to 8080
+      # |   |-- Machine web2 - Updated
+      # |-- Header3
+      # |-- Header4
+      #
+      # In the future, we may even switch it out so you can expand or collapse.
+      #
+      # A single ChildrenTree has these regions:
+      #
+      # |---------------------------------------|
+      # | Gutter | Sub-Region                   |
+      # |        |                              |
+      # |        |------------------------------|
+      # |        | Sub-Region                   |
+      # |        |                              |
+      # |        |------------------------------|
+      # |        | Sub-Region                   |
+      # |        |                              |
+      # |--------|------------------------------|
+
+      class ChildrenTree < ScreenRegionList
+        def initialize(parent)
+          @parent = parent
+          parent.add_region(self) if parent.is_a?(ScreenRegionList)
+        end
+
+        def height
+          gutter.height
+        end
+
+        attr_reader :parent
+        def children
+          @children ||= []
+        end
+
+        def header
+          @header ||= StreamRegion.new()
+        end
+      end
+
+      #
+      # Limits itself to a region of the screen, cutting off display on the right
+      #
+      # Splits up the screen like this:
+      #
+      class RegionStream < ScreenRegion
+        attr_accessor :width
+        attr_accessor :height
+        attr_accessor :header_lines
+        attr_accessor :lines
+      end
+
+      #
+      # Prints lines like
+      # [x.txt] updating ...
+      #
+      #
+      class ParallelRegionStream < RegionStream
+        attr_accessor :
+      end
+    end
+  end
+end
+
+chef_run
+  recipe x
+    file /x/y/z.txt
+      execute ls /x/y/z.txt

data/files/lib/chef_resource/output/simple_output.rb

@@ -0,0 +1,83 @@
+module ChefResource
+  module Chef
+    module Output
+      class SimpleOutput
+        def initialize
+          at_beginning_of_line = true
+        end
+
+        attr_accessor :current_resource
+        attr_accessor :at_beginning_of_line
+
+        def resource_event(resource, event, *args)
+          # Print header for resource
+            indent += 2
+
+            case event
+            when :stdout, :stderr
+              with_stream(resource, event) do
+                print_str(str)
+              end
+
+            when :debug, :info, :warn, :error, :fatal
+              with_stream(resource, event) do
+                begin_line
+                print_str(args[0])
+                begin_line
+              end
+
+            else
+              with_stream(resource, :status) do
+                begin_line
+                print_str(event)
+                begin_line
+              end
+            end
+          end
+        end
+
+        private
+
+        def with_stream(resource, stream)
+          mutex.synchronize do
+            if current_resource != resource
+              begin_line
+              puts "#{' '*indent_for(resource.parent))}#{resource.short_name}"
+              at_beginning_of_line = true
+              current_resource = resource
+            end
+
+            yield
+          end
+        end
+
+        def begin_line
+          if !at_beginning_of_line
+            puts ""
+            at_beginning_of_line = true
+          end
+        end
+
+        def print_str(str)
+          lines = str.lines
+          if !at_beginning_of_line
+            print lines.shift
+          end
+          lines.each do |line|
+            puts "#{' '*indent_for(current_resource)}#{line}"
+          end
+          at_beginning_of_line = str.end_with("\n")
+        end
+
+        def indent_for(resource)
+          indent = 0
+          find_parent = resource
+          while find_parent && find_parent = find_parent.parent_resource
+            indent += 2
+          end
+          indent
+        end
+      end
+    end
+  end
+end

data/files/lib/chef_resource/resource.rb

@@ -0,0 +1,428 @@
+require 'chef_resource'
+require 'chef_resource/resource/resource_log'
+require 'chef_resource/simple_struct'
+
+module ChefResource
+  #
+  # Represents a real thing which can be read and updated.
+  #
+  # When you call YourResource.open(...), it gives you back the Resource's
+  # current value.  This value will often be lazy-loaded, to avoid the often
+  # high performance penalty of accessing real things over network or disk).
+  # You may make modifications to this value (append to it, set properties,
+  # etc.), and then call `update` at the end to save your changes.
+  #
+  # Resources are initialized with `YourResource.open(<identity properties>)`.
+  # After this, the Resource object will have methods and properties that get
+  # you the actual value.  If you want to update the value, the Resource object
+  # lets you modify the values as well; then you call `update` with no
+  # parameters to actually perform the update.
+  #
+  # In general, a Resource:
+  # - MUST have an initial value equal to the actual value (GET).
+  # - SHOULD allow the user to modify the values on the Resource.
+  # - MUST reflect any changes on the Resource itself--i.e. if you set
+  #   file.mode = 0664, then file.mode should == 0664, even if you haven't
+  #   called `update` yet and the actual file has mode `0777`.
+  # - MAY cache actual values on first retrieve for efficiency reasons.
+  # - MUST NOT make any changes to the actual Resource until `update` is called.
+  # - MUST make all user-requested changes in `update`, or raise an error if
+  #   they cannot be fulfilled.
+  # - SHOULD be atomic in that all changes represented in the commit will be
+  #   made available to users at the same time (all switched over at once).
+  # - MAY be transactional in that nested resources are not committed until
+  #   the parent resource is committed.  While this is ideal for many reasons,
+  #   many Resources don't do it because of the difficulty of implementing it.
+  #
+  # ## Defining a Resource Type
+  #
+  # ### Struct
+  #
+  # The simplest way to create a new Resource is with Struct:
+  #
+  # class MyFile < ChefResource::StructResource
+  #   property :path,    Path,   identity: true
+  #   property :content, String
+  #   def load
+  #     File.exist?(path) ? IO.read(content) : nil
+  #   end
+  #   def update
+  #     converge :content do
+  #       IO.write(path.to_s, content)
+  #     end
+  #   end
+  # end
+  #
+  # ### Self-Defined Resource class
+  #
+  # If you did all of this yourself, it would look like this:
+  #
+  # ```ruby
+  # class MyFile
+  #   def initialize(path)
+  #     @path = path
+  #   end
+  #
+  #   attr_reader :path
+  #   attr_writer :content
+  #   def content
+  #     if !defined?(@content)
+  #       begin
+  #         @content = IO.read(path)
+  #       rescue
+  #         @content = nil
+  #       end
+  #       @original_content = @content
+  #     end
+  #   end
+  #   def exists?
+  #     content.nil?
+  #   end
+  #
+  #   def update
+  #     if @content != @original_content
+  #       if !exists?
+  #         puts "#{path} does not exist.  Creating content ..."
+  #       else
+  #         puts "#{path}.content modified.  Updating ..."
+  #       end
+  #       IO.write(path, content)
+  #     end
+  #   end
+  # end
+  # ```
+  #
+  # Resources provide change detection (for idempotence), events, validation,
+  # coercion, lazy loading, resource nesting and compatibility, and automatic
+  # Chef compatibility along with a consistent interface, all wrapped up in a
+  # simple class definition.
+  #
+  # A Resource generally goes through these phases (represented by resource_state):
+  # 1. :created - the Resource object has been created but its identity values are
+  #    not yet filled in.  Because the identity is not yet complete,
+  #    `current_resource` cannot be retrieved: defaults and actual loaded values
+  #    are unavailable.
+  # 2. :identity_defined - The identity of this Resource--the information needed to be
+  #    able to retrieve its actual value--is set.  Identity values are now set
+  #    in stone and can no longer be changed.  `current_resource` is now available,
+  #    and the actual value (get) and default values can now be accessed.
+  #    Note: even though identity is now readonly on the open Resource object,
+  #    the current_resource can set its *own* identity values during `load`, which
+  #    will become the default for those properties.
+  #
+  #    Because the desired value of the Resource is not yet fully known (it
+  #    can still be set), `update` cannot be called in this state.
+  # 3. :fully_defined - This Resource's desired values are now complete.  The
+  #    Resource is now readonly.  `update` is now available.
+  #
+  # TODO thread safety on calling load and update, and on changing and
+  # checking resource_state
+  #
+  module Resource
+    def initialize(*args, &block)
+      super
+      resource_created
+    end
+
+    #
+    # Updates the real resource with desired changes
+    #
+    def update_resource
+      raise NotImplementedError, "#{self.class}.update_resource"
+    end
+
+    #
+    # Load this resource with actual values.  Must set resource_exists = false if the
+    # resource does not exist.
+    #
+    # @raise Various errors if the resource could not be loaded and it is not
+    #   known whether the resource actually exists.
+    #
+    def load
+    end
+
+    #
+    # The remaining methods you don't generally have to explicitly override.
+    #
+
+    extend ChefResource::SimpleStruct
+
+    #
+    # Indicates whether this is the "current resource," an instance loaded in
+    # by accessing `current_resource` on a Resource.
+    #
+    # This affects loading behavior: if the user asks for a value on `current_resource`
+    # that needs to be loaded with `load_value`, it will load the value onto
+    # the current resource if this is set.
+    #
+    boolean_property :is_current_resource
+
+    #
+    # The underlying value of this resource.  Any values the user has not
+    # filled in will be based on this.
+    #
+    # This method may return the actual value, or the default value (if the
+    # actual_value does not exist).
+    #
+    # The first time this is called, it will attempt to load the actual value,
+    # caching it or recording the fact that it does not exist.
+    #
+    def current_resource(resource=NOT_PASSED)
+      if resource != NOT_PASSED
+        @current_resource = resource
+      else
+        # If this is the first time we've been called, calculate current_resource as
+        # either the current value, or the default value if there is no current
+        # value.
+        if !defined?(@current_resource) && !is_current_resource?
+
+          if resource_state == :created
+            raise ResourceStateError.new("Resource cannot be loaded (and defaults cannot be read) until the identity is defined", self)
+          end
+
+          @current_resource = load_current_resource
+        end
+
+        @current_resource
+      end
+    end
+
+
+    #
+    # Loads the current actual value of this Resources into a new struct, storing
+    # the resulting value in `current_resource`.
+    #
+    # The default implementation calls `reopen_resource` and then calls `load`
+    # on the new Resource object.
+    #
+    def load_current_resource
+      # Reopen the resource (it's in :identity_defined state) with
+      # `identity` values copied over.
+      loading_resource = reopen_resource
+      loading_resource.is_current_resource = true
+      # We store it as soon as we have it, to ensure loops can't happen.
+      @current_resource = loading_resource
+
+      # Run "load"
+      log.load_started
+      begin
+        loading_resource.load
+        log.load_succeeded
+        @current_resource
+
+      rescue
+        log.load_failed($!)
+        raise
+      end
+    end
+
+    #
+    # Whether the current resource has been loaded.
+    #
+    # @return [Boolean] Whether the current resource has been loaded.  This will
+    #   be true if the attempt was made, even if it failed to load or does not
+    #   actually exist.
+    #
+    def current_resource_loaded?
+      defined?(@current_resource)
+    end
+
+    #
+    # Get a new copy of the Resource with only identity values set.
+    #
+    # Note: the Resource remains in :created state, not :identity_defined as
+    # one would get from `open`.  Call resource_identity_defined if you want
+    # to be able to retrieve actual values.
+    #
+    # This method is used by ResourceType.get() and Resource.reload.
+    #
+    def reopen_resource
+      raise NotImplementedError, "#{self.class}.reopen_resource"
+    end
+
+    #
+    # Set the actual value.
+    #
+    def current_resource=(resource)
+      @current_resource = resource
+    end
+
+    #
+    # Set whether this resource exists or not.
+    #
+    def resource_exists=(value)
+      @resource_exists = value
+    end
+
+    #
+    # Get/set whether this resource exists.
+    #
+    def resource_exists(value=NOT_PASSED)
+      if value == NOT_PASSED
+        if defined?(@resource_exists)
+          @resource_exists
+        elsif current_resource
+          current_resource.resource_exists?
+        else
+          # Defaults to true if there is no current_resource.
+          true
+        end
+      else
+        @resource_exists = value
+      end
+    end
+
+    #
+    # Whether this resource exists or not.
+    #
+    alias :resource_exists? :resource_exists
+
+    #
+    # Resets the Resource so that `update` will make no changes and its value
+    # will be the same as the actual value.
+    #
+    def reset
+      raise NotImplementedError, "#{self.class}.reset"
+    end
+
+    #
+    # An object with log methods: `debug`, `info`, `warn`, `error`, `fatal`, `opened`, `defined`, `updated`, `failed`
+    #
+    # @example Logging directly (info level)
+    #   your_resource.log('hi there')
+    # @example Using the log object
+    #   your_resource.log.error "Oh noes"
+    #
+    def log(str=nil)
+      @resource_log ||= ResourceLog.new(self)
+      if str
+        @resource_log.info(str)
+        @resource_log
+      else
+        @resource_log
+      end
+    end
+
+    #
+    # The state of this resource.  It moves through four phases:
+    # - :created - has been created, but not fully opened (still initializing).
+    #   Only identity values are writeable in this state.
+    # - :identity_defined - has been opened (has enough data to retrieve the actual value)
+    #   Identity properties are readonly in this state.
+    # - :fully_defined - has been fully defined (properties are now readonly)
+    #   All properties are readonly in this state.
+    #
+    def resource_state
+      @resource_state
+    end
+
+    #
+    # Notify the resource that it has been created (and is now open to write
+    # identity properties).  This happens automatically during initialize and
+    # before any identity properties are set.
+    #
+    def resource_created
+      @resource_state = :created
+      log.created
+    end
+
+    #
+    # Notify the resource that it is fully opened and ready to read and write.
+    #
+    # Identity properties are readonly in this state.
+    #
+    def resource_identity_defined
+      case resource_state
+      when :created
+        @resource_state = :identity_defined
+        log.identity_defined
+      when :identity_defined
+      else
+        raise "Cannot move a resource from #{@resource_state} to open"
+      end
+    end
+
+    #
+    # Shut down the definition of the resource.
+    #
+    # The entire resource is readonly in this state.
+    #
+    def resource_fully_defined
+      case resource_state
+      when :created
+        resource_identity_defined
+        @resource_state = :fully_defined
+        log.fully_defined
+      when :identity_defined
+        @resource_state = :fully_defined
+        log.fully_defined
+      when :fully_defined
+      else
+        raise "Cannot move a resource from #{@resource_state} to defined"
+      end
+    end
+
+    #
+    # Update events and print stuff
+    #
+
+    #
+    # Take an action that will update the resource.
+    #
+    # @param description [String] The action being taken.
+    # @yield A block that will perform the actual update.
+    # @raise Any error raised by the block is passed through.
+    #
+    def take_action(description, &action_block)
+      log.action_started(description)
+      begin
+        instance_eval(&action_block)
+      rescue
+        log.action_failed($!)
+        raise
+      end
+      log.action_succeeded
+    end
+
+    #
+    # Take an action that may or may not update the resource.
+    #
+    # @param description [String] The action being attempted.
+    # @yield A block that will perform the actual update.
+    # @yieldreturn [Boolean String] `true` or a String describing the update if
+    #   the resource was updated; `false` if the resource did not need to be
+    #   updated.
+    # @raise Any error raised by the block is passed through.
+    #
+    def try_action(description, &action_block)
+      log.action_started(description, update_guaranteed: false)
+      begin
+        result = instance_eval(&action_block)
+      rescue
+        log.action_failed($!)
+        raise
+      end
+
+      if result.is_a?(String)
+        log.action_succeeded(updated: true, update_description: result)
+      elsif result
+        log.action_succeeded(updated: true)
+      else
+        log.action_succeeded(updated: false)
+      end
+    end
+
+    #
+    # Record the fact that we skipped an action.
+    #
+    def skip_action(description)
+      log.action_started(description, update_guaranteed: false)
+      log.action_succeeded(updated: false)
+    end
+
+    # A short name for this resource for output formatters
+    def resource_short_name
+      raise NotImplementedError
+    end
+  end
+end