ridley 0.10.2 → 0.11.0.rc1

data/lib/ridley/chef_objects/cookbook_object.rb

@@ -0,0 +1,190 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class CookbookObject < Ridley::ChefObject
+    include Ridley::Logging
+
+    FILE_TYPES = [
+      :resources,
+      :providers,
+      :recipes,
+      :definitions,
+      :libraries,
+      :attributes,
+      :files,
+      :templates,
+      :root_files
+    ].freeze
+
+    set_chef_id "name"
+    set_chef_type "cookbook"
+    set_chef_json_class "Chef::Cookbook"
+
+    attribute :name,
+      required: true
+
+    attribute :attributes,
+      type: Array,
+      default: Array.new
+
+    attribute :cookbook_name,
+      type: String
+
+    attribute :definitions,
+      type: Array,
+      default: Array.new
+
+    attribute :files,
+      type: Array,
+      default: Array.new
+
+    attribute :libraries,
+      type: Array,
+      default: Array.new
+
+    attribute :metadata,
+      type: Hashie::Mash
+
+    attribute :providers,
+      type: Array,
+      default: Array.new
+
+    attribute :recipes,
+      type: Array,
+      default: Array.new
+
+    attribute :resources,
+      type: Array,
+      default: Array.new
+
+    attribute :root_files,
+      type: Array,
+      default: Array.new
+
+    attribute :templates,
+      type: Array,
+      default: Array.new
+
+    attribute :version,
+      type: String
+
+    attribute :frozen?,
+      type: Boolean
+
+    # Download the entire cookbook
+    #
+    # @param [String] destination (Dir.mktmpdir)
+    #   the place to download the cookbook too. If no value is provided the cookbook
+    #   will be downloaded to a temporary location
+    #
+    # @return [String]
+    #   the path to the directory the cookbook was downloaded to
+    def download(destination = Dir.mktmpdir)
+      destination = File.expand_path(destination)
+      log.debug { "downloading cookbook: '#{name}'" }
+
+      FILE_TYPES.each do |filetype|
+        next unless manifest.has_key?(filetype)
+
+        manifest[filetype].each do |file|
+          file_destination = File.join(destination, file[:path].gsub('/', File::SEPARATOR))
+          FileUtils.mkdir_p(File.dirname(file_destination))
+          download_file(filetype, file[:path], file_destination)
+        end
+      end
+
+      destination
+    end
+
+    # Download a single file from a cookbook
+    #
+    # @param [#to_sym] filetype
+    #   the type of file to download. These are broken up into the following types in Chef:
+    #     - attribute (unsupported until resolved https://github.com/reset/chozo/issues/17)
+    #     - definition
+    #     - file
+    #     - library
+    #     - provider
+    #     - recipe
+    #     - resource
+    #     - root_file
+    #     - template
+    #   these types are where the files are stored in your cookbook's structure. For example, a
+    #   recipe would be stored in the recipes directory while a root_file is stored at the root
+    #   of your cookbook
+    # @param [String] path
+    #   path of the file to download
+    # @param [String] destination
+    #   where to download the file to
+    #
+    # @return [nil]
+    def download_file(filetype, path, destination)
+      download_fun(filetype).call(path, destination)
+    end
+
+    # A hash containing keys for all of the different cookbook filetypes with values
+    # representing each file of that type this cookbook contains
+    #
+    # @example
+    #   {
+    #     root_files: [
+    #       {
+    #         :name => "afile.rb",
+    #         :path => "files/ubuntu-9.10/afile.rb",
+    #         :checksum => "2222",
+    #         :specificity => "ubuntu-9.10"
+    #       },
+    #     ],
+    #     templates: [ manifest_record1, ... ],
+    #     ...
+    #   }
+    #
+    # @return [Hash]
+    def manifest
+      {}.tap do |manifest|
+        FILE_TYPES.each do |filetype|
+          manifest[filetype] = get_attribute(filetype)
+        end
+      end
+    end
+
+    def to_s
+      "#{name}: #{manifest}"
+    end
+
+    private
+
+      # Return a lambda for downloading a file from the cookbook of the given type
+      #
+      # @param [#to_sym] filetype
+      #
+      # @return [lambda]
+      #   a lambda which takes to parameters: target and path. Target is the URL to download from
+      #   and path is the location on disk to steam the contents of the remote URL to.
+      def download_fun(filetype)
+        collection = case filetype.to_sym
+        when :attribute, :attributes; method(:attributes)
+        when :definition, :definitions; method(:definitions)
+        when :file, :files; method(:files)
+        when :library, :libraries; method(:libraries)
+        when :provider, :providers; method(:providers)
+        when :recipe, :recipes; method(:recipes)
+        when :resource, :resources; method(:resources)
+        when :root_file, :root_files; method(:root_files)
+        when :template, :templates; method(:templates)
+        else
+          raise Errors::UnknownCookbookFileType.new(filetype)
+        end
+
+        ->(target, destination) {
+          files = collection.call # JW: always chaining .call.find results in a nil value. WHY?
+          file  = files.find { |f| f[:path] == target }
+          return nil if file.nil?
+
+          destination = File.expand_path(destination)
+          log.debug { "downloading '#{filetype}' file: #{file} to: '#{destination}'" }
+
+          connection.stream(file[:url], destination)
+        }
+      end
+  end
+end

data/lib/ridley/chef_objects/data_bag_item_obect.rb

@@ -0,0 +1,104 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class DataBagItemObject < ChefObject
+    set_chef_id "id"
+    set_assignment_mode :carefree
+
+    # @return [Ridley::DataBagObject]
+    attr_reader :data_bag
+
+    attribute :id,
+      type: String,
+      required: true
+
+    alias_method :attributes=, :mass_assign
+    alias_method :attributes, :_attributes_
+
+    # @param [Ridley::DataBagItemResource] resource
+    # @param [Ridley::DataBagObject] data_bag
+    # @param [#to_hash] new_attrs
+    def initialize(resource, data_bag, new_attrs = {})
+      super(resource, new_attrs)
+      @data_bag = data_bag
+    end
+
+    # Creates a resource on the target remote or updates one if the resource
+    # already exists.
+    #
+    # @raise [Errors::InvalidResource]
+    #   if the resource does not pass validations
+    #
+    # @return [Boolean]
+    #   true if successful and false for failure
+    def save
+      raise Errors::InvalidResource.new(self.errors) unless valid?
+
+      mass_assign(resource.create(data_bag, self)._attributes_)
+      true
+    rescue Errors::HTTPConflict
+      self.update
+      true
+    end
+
+    # Decrypts this data bag item.
+    #
+    # @return [Hash] decrypted attributes
+    def decrypt
+      decrypted_hash = Hash[_attributes_.map { |key, value| [key, key == "id" ? value : decrypt_value(value)] }]
+      mass_assign(decrypted_hash)
+    end
+
+    def decrypt_value(value)
+      if encrypted_data_bag_secret.nil?
+        raise Errors::EncryptedDataBagSecretNotSet
+      end
+
+      decoded_value = Base64.decode64(value)
+
+      cipher = OpenSSL::Cipher::Cipher.new('aes-256-cbc')
+      cipher.decrypt
+      cipher.pkcs5_keyivgen(encrypted_data_bag_secret)
+      decrypted_value = cipher.update(decoded_value) + cipher.final
+
+      YAML.load(decrypted_value)
+    end
+
+    # Reload the attributes of the instantiated resource
+    #
+    # @return [Object]
+    def reload
+      mass_assign(resource.find(data_bag, self)._attributes_)
+      self
+    end
+
+    # Updates the instantiated resource on the target remote with any changes made
+    # to self
+    #
+    # @raise [Errors::InvalidResource]
+    #   if the resource does not pass validations
+    #
+    # @return [Boolean]
+    def update
+      raise Errors::InvalidResource.new(self.errors) unless valid?
+
+      mass_assign(resource.update(data_bag, self)._attributes_)
+      true
+    end
+
+    # @param [#to_hash] hash
+    #
+    # @return [Object]
+    def from_hash(hash)
+      hash = Hashie::Mash.new(hash.to_hash)
+
+      mass_assign(hash.has_key?(:raw_data) ? hash[:raw_data] : hash)
+      self
+    end
+
+    private
+
+      def encrypted_data_bag_secret
+        resource.encrypted_data_bag_secret
+      end
+  end
+end

data/lib/ridley/chef_objects/data_bag_object.rb

@@ -0,0 +1,31 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class DataBagObject < ChefObject
+    set_chef_id "name"
+
+    attribute :name,
+      required: true
+
+    def item
+      DataBagItemProxy.new(self, resource.item_resource)
+    end
+
+    # @author Jamie Winsor <reset@riotgames.com>
+    # @api private
+    class DataBagItemProxy
+      attr_reader :data_bag_object
+      attr_reader :item_resource
+
+      # @param [Ridley::DataBagObject] data_bag_object
+      # @param [Ridley::DataBagItemResource] item_resource
+      def initialize(data_bag_object, item_resource)
+        @data_bag_object = data_bag_object
+        @item_resource   = item_resource
+      end
+
+      def method_missing(fun, *args, &block)
+        @item_resource.send(fun, data_bag_object, *args, &block)
+      end
+    end
+  end
+end

data/lib/ridley/chef_objects/environment_object.rb

@@ -0,0 +1,59 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class EnvironmentObject < Ridley::ChefObject
+    set_chef_id "name"
+    set_chef_type "environment"
+    set_chef_json_class "Chef::Environment"
+
+    attribute :name,
+      required: true
+
+    attribute :description,
+      default: String.new
+
+    attribute :default_attributes,
+      default: Hashie::Mash.new
+
+    attribute :override_attributes,
+      default: Hashie::Mash.new
+
+    attribute :cookbook_versions,
+      default: Hashie::Mash.new
+
+    # Set an environment level default attribute given the dotted path representation of
+    # the Chef attribute and value
+    #
+    # @example setting and saving an environment level default attribute
+    #
+    #   obj = environment.find("production")
+    #   obj.set_default_attribute("my_app.billing.enabled", false)
+    #   obj.save
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @return [HashWithIndifferentAccess]
+    def set_default_attribute(key, value)
+      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
+      self.default_attributes = self.default_attributes.deep_merge(attr_hash)
+    end
+
+    # Set an environment level override attribute given the dotted path representation of
+    # the Chef attribute and value
+    #
+    # @example setting and saving an environment level override attribute
+    #
+    #   obj = environment.find("production")
+    #   obj.set_override_attribute("my_app.billing.enabled", false)
+    #   obj.save
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @return [HashWithIndifferentAccess]
+    def set_override_attribute(key, value)
+      attr_hash = HashWithIndifferentAccess.from_dotted_path(key, value)
+      self.override_attributes = self.override_attributes.deep_merge(attr_hash)
+    end
+  end
+end

data/lib/ridley/chef_objects/node_object.rb

@@ -0,0 +1,161 @@
+module Ridley
+  # @author Jamie Winsor <reset@riotgames.com>
+  class NodeObject < Ridley::ChefObject
+    set_chef_id "name"
+    set_chef_type "node"
+    set_chef_json_class "Chef::Node"
+
+    attribute :name,
+      required: true
+
+    attribute :chef_environment,
+      default: "_default"
+
+    attribute :automatic,
+      default: Hashie::Mash.new
+
+    attribute :normal,
+      default: Hashie::Mash.new
+
+    attribute :default,
+      default: Hashie::Mash.new
+
+    attribute :override,
+      default: Hashie::Mash.new
+
+    attribute :run_list,
+      default: Array.new
+
+    alias_method :normal_attributes, :normal
+    alias_method :automatic_attributes, :automatic
+    alias_method :default_attributes, :default
+    alias_method :override_attributes, :override
+
+    alias_method :normal_attributes=, :normal=
+    alias_method :automatic_attributes=, :automatic=
+    alias_method :default_attributes=, :default=
+    alias_method :override_attributes=, :override=
+
+    # Set a node level normal attribute given the dotted path representation of the Chef
+    # attribute and value.
+    #
+    # @note It is not possible to set any other attribute level on a node and have it persist after
+    #   a Chef Run. This is because all other attribute levels are truncated at the start of a Chef Run.
+    #
+    # @example setting and saving a node level normal attribute
+    #
+    #   obj = node.find("jwinsor-1")
+    #   obj.set_chef_attribute("my_app.billing.enabled", false)
+    #   obj.save
+    #
+    # @param [String] key
+    # @param [Object] value
+    #
+    # @return [Hashie::Mash]
+    def set_chef_attribute(key, value)
+      attr_hash   = Hashie::Mash.from_dotted_path(key, value)
+      self.normal = self.normal.deep_merge(attr_hash)
+    end
+
+    # Returns the public hostname of the instantiated node. This hostname should be used for
+    # public communications to the node.
+    #
+    # @example
+    #   node.public_hostname => "reset.riotgames.com"
+    #
+    # @return [String]
+    def public_hostname
+      self.cloud? ? self.automatic[:cloud][:public_hostname] : self.automatic[:fqdn]
+    end
+
+    # Returns the public IPv4 address of the instantiated node. This ip address should be
+    # used for public communications to the node.
+    #
+    # @example
+    #   node.public_ipv4 => "10.33.33.1"
+    #
+    # @return [String]
+    def public_ipv4
+      self.cloud? ? self.automatic[:cloud][:public_ipv4] : self.automatic[:ipaddress]
+    end
+    alias_method :public_ipaddress, :public_ipv4
+
+    # Returns the cloud provider of the instantiated node. If the node is not identified as
+    # a cloud node, then nil is returned.
+    #
+    # @example
+    #   node_1.cloud_provider => "eucalyptus"
+    #   node_2.cloud_provider => "ec2"
+    #   node_3.cloud_provider => "rackspace"
+    #   node_4.cloud_provider => nil
+    #
+    # @return [nil, String]
+    def cloud_provider
+      self.cloud? ? self.automatic[:cloud][:provider] : nil
+    end
+
+    # Returns true if the node is identified as a cloud node.
+    #
+    # @return [Boolean]
+    def cloud?
+      self.automatic.has_key?(:cloud)
+    end
+
+    # Returns true if the node is identified as a cloud node using the eucalyptus provider.
+    #
+    # @return [Boolean]
+    def eucalyptus?
+      self.cloud_provider == "eucalyptus"
+    end
+
+    # Returns true if the node is identified as a cloud node using the ec2 provider.
+    #
+    # @return [Boolean]
+    def ec2?
+      self.cloud_provider == "ec2"
+    end
+
+    # Returns true if the node is identified as a cloud node using the rackspace provider.
+    #
+    # @return [Boolean]
+    def rackspace?
+      self.cloud_provider == "rackspace"
+    end
+
+    # Executes a Chef run on the node
+    #
+    # @return [HostConnector::Response]
+    def chef_run
+      resource.chef_run(self.public_hostname)
+    end
+
+    # Puts the configured encrypted data bag secret on the node
+    #
+    # @return [HostConnector::Response]
+    def put_secret
+      resource.put_secret(self.public_hostname)
+    end
+
+    # Merges the instaniated nodes data with the given data and updates
+    # the remote with the merged results
+    #
+    # @option options [Array] :run_list
+    #   run list items to merge
+    # @option options [Hash] :attributes
+    #   attributes of normal precedence to merge
+    #
+    # @return [Ridley::NodeResource]
+    def merge_data(options = {})
+      unless options[:run_list].nil?
+        self.run_list = (self.run_list + Array(options[:run_list])).uniq
+      end
+
+      unless options[:attributes].nil?
+        self.normal = self.normal.deep_merge(options[:attributes])
+      end
+
+      self.update
+      self
+    end
+  end
+end