chef-infra-api 0.9.1

data/lib/chef-api/resources/client.rb

@@ -0,0 +1,84 @@
+module ChefAPI
+  class Resource::Client < Resource::Base
+    include ChefAPI::AclAble
+    collection_path '/clients'
+
+    schema do
+      attribute :name,        type: String,  primary: true, required: true
+      attribute :admin,       type: Boolean, default: false
+      attribute :public_key,  type: String
+      attribute :private_key, type: [String, Boolean], default: false
+      attribute :validator,   type: Boolean, default: false
+
+      ignore :certificate, :clientname, :orgname
+    end
+
+    # @todo implement
+    protect 'chef-webui', 'chef-validator'
+
+    class << self
+      #
+      # Load the client from a .pem file on disk. Lots of assumptions are made
+      # here.
+      #
+      # @param [String] path
+      #   the path to the client on disk
+      #
+      # @return [Resource::Client]
+      #
+      def from_file(path)
+        name, key = Util.safe_read(path)
+
+        if client = fetch(name)
+          client.private_key = key
+          client
+        else
+          new(name: name, private_key: key)
+        end
+      end
+    end
+
+    #
+    # Override the loading of the client. Since HEC and EC both return
+    # +certificate+, but OPC and CZ both use +public_key+. In order to
+    # normalize this discrepancy, the intializer converts the response from
+    # the server OPC format. HEC and EC both handle putting a public key to
+    # the server instead of a certificate.
+    #
+    # @see Resource::Base#initialize
+    #
+    def initialize(attributes = {}, prefix = {})
+      if certificate = attributes.delete(:certificate) ||
+                       attributes.delete('certificate')
+        x509 = OpenSSL::X509::Certificate.new(certificate)
+        attributes[:public_key] = x509.public_key.to_pem
+      end
+
+      super
+    end
+
+    #
+    # Generate a new RSA private key for this API client.
+    #
+    # @example Regenerate the private key
+    #   key = client.regenerate_key
+    #   key #=> "-----BEGIN PRIVATE KEY-----\nMIGfMA0GCS..."
+    #
+    # @note For security reasons, you should perform this operation sparingly!
+    #   The resulting private key is committed to this object, meaning it is
+    #   saved to memory somewhere. You should set this resource's +private_key+
+    #   to +nil+ after you have committed it to disk and perform a manual GC to
+    #   be ultra-secure.
+    #
+    # @note Regenerating the private key also regenerates the public key!
+    #
+    # @return [self]
+    #   the current resource with the new public and private key attributes
+    #
+    def regenerate_keys
+      raise Error::CannotRegenerateKey if new_resource?
+      update(private_key: true).save!
+      self
+    end
+  end
+end

data/lib/chef-api/resources/collection_proxy.rb

@@ -0,0 +1,234 @@
+module ChefAPI
+  class Resource::CollectionProxy
+    include Enumerable
+
+    #
+    # Create a new collection proxy from the given parent class and collection
+    # information. The collection proxy aims to make working with nested
+    # resource collections a bit easier. The proxy waits until non-existing
+    # data is requested before making another HTTP request. In this way, it
+    # helps reduce bandwidth and API requets.
+    #
+    # Additionally, the collection proxy caches the results of an object request
+    # in memory by +id+, so additional requests for the same object will hit the
+    # cache, again reducing HTTP requests.
+    #
+    # @param [Resource::Base] parent
+    #   the parent resource that created the collection
+    # @param [Class] klass
+    #   the class the resulting objects should be
+    # @param [String] endpoint
+    #   the relative path for the RESTful endpoint
+    #
+    # @return [CollectionProxy]
+    #
+    def initialize(parent, klass, endpoint, prefix = {})
+      @parent     = parent
+      @klass      = klass
+      @endpoint   = "#{parent.resource_path}/#{endpoint}"
+      @prefix     = prefix
+      @collection = load_collection
+    end
+
+    #
+    # Force a reload of this collection proxy and all its elements. This is
+    # useful if you think additional items have been added to the remote
+    # collection and need access to them locally. This will also clear any
+    # existing cached responses, so use with caution.
+    #
+    # @return [self]
+    #
+    def reload!
+      cache.clear
+      @collection = load_collection
+
+      self
+    end
+
+    #
+    # Fetch a specific resource in the collection by id.
+    #
+    # @example Fetch a resource
+    #   Bacon.first.items.fetch('crispy')
+    #
+    # @param [String, Symbol] id
+    #   the id of the resource to fetch
+    #
+    # @return [Resource::Base, nil]
+    #   the fetched class, or nil if it does not exists
+    #
+    def fetch(id)
+      return nil unless exists?(id)
+      cached(id) { klass.from_url(get(id), prefix) }
+    end
+
+    #
+    # Determine if the resource with the given id exists on the remote Chef
+    # Server. This method does not actually query the Chef Server, but rather
+    # delegates to the cached collection. To guarantee the most fresh set of
+    # data, you should call +reload!+ before +exists?+ to ensure you have the
+    # most up-to-date collection of resources.
+    #
+    # @param [String, Symbol] id
+    #   the unique id of the resource to find.
+    #
+    # @return [Boolean]
+    #   true if the resource exists, false otherwise
+    #
+    def exists?(id)
+      collection.has_key?(id.to_s)
+    end
+
+    #
+    # Get the full list of all entries in the collection. This method is
+    # incredibly expensive and should only be used when you absolutely need
+    # all resources. If you need a specific resource, you should use an iterator
+    # such as +select+ or +find+ instead, since it will minimize HTTP requests.
+    # Once all the objects are requested, they are cached, reducing the number
+    # of HTTP requests.
+    #
+    # @return [Array<Resource::Base>]
+    #
+    def all
+      entries
+    end
+
+    #
+    # The custom iterator for looping over each object in this collection. For
+    # more information, please see the +Enumerator+ module in Ruby core.
+    #
+    def each(&block)
+      collection.each do |id, url|
+        object = cached(id) { klass.from_url(url, prefix) }
+        block.call(object) if block
+      end
+    end
+
+    #
+    # The total number of items in this collection. This method does not make
+    # an API request, but rather counts the number of keys in the given
+    # collection.
+    #
+    def count
+      collection.length
+    end
+    alias_method :size, :count
+
+    #
+    # The string representation of this collection proxy.
+    #
+    # @return [String]
+    #
+    def to_s
+      "#<#{self.class.name}>"
+    end
+
+    #
+    # The detailed string representation of this collection proxy.
+    #
+    # @return [String]
+    #
+    def inspect
+      objects = collection
+        .map { |id, _| cached(id) || klass.new(klass.schema.primary_key => id) }
+        .map { |object| object.to_s }
+
+      "#<#{self.class.name} [#{objects.join(', ')}]>"
+    end
+
+    private
+
+    attr_reader :collection
+    attr_reader :endpoint
+    attr_reader :klass
+    attr_reader :parent
+    attr_reader :prefix
+
+    #
+    # Fetch the object collection from the Chef Server. Since the Chef Server's
+    # API is completely insane and all over the place, it might return a Hash
+    # where the key is the id of the resource and the value is the url for that
+    # item on the Chef Server:
+    #
+    #     { "key" => "url" }
+    #
+    # Or if the Chef Server's fancy is tickled, it might just return an array
+    # of the list of items:
+    #
+    #     ["item_1", "item_2"]
+    #
+    # Or if the Chef Server is feeling especially magical, it might return the
+    # actual objects, but prefixed with the JSON id:
+    #
+    #     [{"organization" => {"_id" => "..."}}, {"organization" => {...}}]
+    #
+    # So, this method attempts to intelligent handle these use cases. That being
+    # said, I can almost guarantee that someone is going to do some crazy
+    # strange edge case with this library and hit a bug here, so it will likely
+    # be changed in the future. For now, it "works on my machine".
+    #
+    # @return [Hash]
+    #
+    def load_collection
+      case response = Resource::Base.connection.get(endpoint)
+      when Array
+        if response.first.is_a?(Hash)
+          key = klass.schema.primary_key.to_s
+
+          {}.tap do |hash|
+            response.each do |results|
+              results.each do |_, info|
+                hash[key] = klass.resource_path(info[key])
+              end
+            end
+          end
+        else
+          Hash[*response.map { |item| [item, klass.resource_path(item)] }.flatten]
+        end
+      when Hash
+        response
+      end
+    end
+
+    #
+    # Retrieve a cached value. This method helps significantly reduce the
+    # number of HTTP requests made against the remote server.
+    #
+    # @param [String, Symbol] key
+    #   the cache key (typically the +name+ of the resource)
+    # @param [Proc] block
+    #   the block to evaluate to set the value if it doesn't exist
+    #
+    # @return [Object]
+    #   the value at the cache
+    #
+    def cached(key, &block)
+      cache[key.to_sym] ||= block ? block.call : nil
+    end
+
+    #
+    # The cache...
+    #
+    # @return [Hash]
+    #
+    def cache
+      @cache ||= {}
+    end
+
+    #
+    # Retrieve a specific item in the collection. Note, this will always return
+    # the original raw record (with the key => URL pairing), not a cached
+    # resource.
+    #
+    # @param [String, Symbol] id
+    #   the id of the resource to fetch
+    #
+    # @return [String, nil]
+    #   the URL to retrieve the item in the collection, or nil if it does not
+    #   exist
+    #
+    def get(id)
+      collection[id.to_s]
+    end
+  end
+end

data/lib/chef-api/resources/cookbook.rb

@@ -0,0 +1,24 @@
+module ChefAPI
+  #
+  # In the real world, a "cookbook" is a single entity with multiple versions.
+  # In Chef land, a "cookbook" is actually just a wrapper around a collection
+  # of +cookbook_version+ objects that fully detail the layout of a cookbook.
+  #
+  class Resource::Cookbook < Resource::Base
+    collection_path '/cookbooks'
+
+    schema do
+      attribute :name, type: String, primary: true, required: true
+    end
+
+    has_many :versions,
+      class_name: CookbookVersion,
+      rest_endpoint: '/?num_versions=all'
+
+    class << self
+      def from_json(response, prefix = {})
+        new(name: response.keys.first)
+      end
+    end
+  end
+end

data/lib/chef-api/resources/cookbook_version.rb

@@ -0,0 +1,23 @@
+module ChefAPI
+  class Resource::CookbookVersion < Resource::Base
+    collection_path '/cookbooks/:cookbook'
+
+    schema do
+      attribute :name,          type: String,  primary: true, required: true
+      attribute :cookbook_name, type: String,  required: true
+      attribute :metadata,      type: Hash,    required: true
+      attribute :version,       type: String,  required: true
+      attribute :frozen?,       type: Boolean, default: false
+
+      attribute :attributes,  type: Array, default: []
+      attribute :definitions, type: Array, default: []
+      attribute :files,       type: Array, default: []
+      attribute :libraries,   type: Array, default: []
+      attribute :providers,   type: Array, default: []
+      attribute :recipes,     type: Array, default: []
+      attribute :resources,   type: Array, default: []
+      attribute :root_files,  type: Array, default: []
+      attribute :templates,   type: Array, default: []
+    end
+  end
+end

data/lib/chef-api/resources/data_bag.rb

@@ -0,0 +1,136 @@
+module ChefAPI
+  class Resource::DataBag < Resource::Base
+    collection_path '/data'
+
+    schema do
+      attribute :name, type: String, primary: true, required: true
+    end
+
+    class << self
+      #
+      # Load the data bag from a collection of JSON files on disk. Just like
+      # +knife+, the basename of the folder is assumed to be the name of the
+      # data bag and all containing items a proper JSON data bag.
+      #
+      # This will load **all** items in the data bag, returning an array of
+      # those items. To load an individual data bag item, see
+      # {DataBagItem.from_file}.
+      #
+      # **This method does NOT return an instance of a {DataBag}!**
+      #
+      # @param [String] path
+      #   the path to the data bag **folder** on disk
+      # @param [String] name
+      #   the name of the data bag
+      #
+      # @return [Array<DataBagItem>]
+      #
+      def from_file(path, name = File.basename(path))
+        path  = File.expand_path(path)
+
+        raise Error::FileNotFound.new(path: path)  unless File.exists?(path)
+        raise Error::NotADirectory.new(path: path) unless File.directory?(path)
+
+        raise ArgumentError unless File.directory?(path)
+
+        bag = new(name: name)
+
+        Util.fast_collect(Dir["#{path}/*.json"]) do |item|
+          Resource::DataBagItem.from_file(item, bag)
+        end
+      end
+
+      #
+      #
+      #
+      def fetch(id, prefix = {})
+        return nil if id.nil?
+
+        path     = resource_path(id, prefix)
+        response = connection.get(path)
+        new(name: id)
+      rescue Error::HTTPNotFound
+        nil
+      end
+
+      #
+      #
+      #
+      def each(&block)
+        collection.each do |name, path|
+          result = new(name: name)
+          block.call(result) if block
+        end
+      end
+    end
+
+    #
+    # This is the same as +has_many :items+, but creates a special collection
+    # for data bag items, which is mutable and handles some special edge cases
+    # that only data bags encounter.
+    #
+    # @see Base.has_many
+    #
+    def items
+      associations[:items] ||= Resource::DataBagItemCollectionProxy.new(self)
+    end
+  end
+end
+
+module ChefAPI
+  #
+  # The mutable collection is a special kind of collection proxy that permits
+  # Rails-like attribtue creation, like:
+  #
+  #   DataBag.first.items.create(id: 'me', thing: 'bar', zip: 'zap')
+  #
+  class Resource::DataBagItemCollectionProxy < Resource::CollectionProxy
+    def initialize(bag)
+      # Delegate to the superclass
+      super(bag, Resource::DataBagItem, nil, bag: bag.name)
+    end
+
+    # @see klass.new
+    def new(data = {})
+      klass.new(data, prefix, parent)
+    end
+
+    # @see klass.destroy
+    def destroy(id)
+      klass.destroy(id, prefix)
+    ensure
+      reload!
+    end
+
+    # @see klass.destroy_all
+    def destroy_all
+      klass.destroy_all(prefix)
+    ensure
+      reload!
+    end
+
+    # @see klass.build
+    def build(data = {})
+      klass.build(data, prefix)
+    end
+
+    # @see klass.create
+    def create(data = {})
+      klass.create(data, prefix)
+    ensure
+      reload!
+    end
+
+    # @see klass.create!
+    def create!(data = {})
+      klass.create!(data, prefix)
+    ensure
+      reload!
+    end
+
+    # @see klass.update
+    def update(id, data = {})
+      klass.update(id, data, prefix)
+    end
+  end
+end