spice 0.8.0 → 1.0.0.pre

data/lib/spice/connection.rb

@@ -1,81 +1,94 @@
 require 'yajl'
+require 'uri'
+
+require 'spice/request'
+require 'spice/connection/authentication'
+require 'spice/connection/search'
+require 'spice/connection/clients'
+require 'spice/connection/cookbooks'
+require 'spice/connection/data_bags'
+require 'spice/connection/environments'
+require 'spice/connection/nodes'
+require 'spice/connection/roles'
+require 'spice/connection/search'
 
 module Spice
   class Connection
-    attr_accessor :client_name, :key_file, :auth_credentials, :server_url, :url_path
+    include Toy::Store
+    store :memory, {}
     
-    def initialize(options={})
-      endpoint          = URI.parse(options[:server_url])
-      @server_url       = options[:server_url]
-      @host             = endpoint.host
-      @port             = endpoint.port
-      @scheme           = endpoint.scheme
-      @url_path         = endpoint.path
-      @auth_credentials = Authentication.new(options[:client_name], options[:key_file])
-      @sign_on_redirect, @sign_request = true, true
-    end
+    include Spice::Connection::Clients
+    include Spice::Connection::Cookbooks
+    include Spice::Connection::DataBags
+    include Spice::Connection::Environments
+    include Spice::Connection::Nodes
+    include Spice::Connection::Roles
+    include Spice::Connection::Search
+    include Spice::Connection::Authentication
+    include Spice::Connection::Search
+    include Spice::Request
+        
+    attribute :client_name, String
+    attribute :key_file, String
+    attribute :key, String
+    attribute :server_url, String
+    attribute :sign_on_redirect, Boolean, :default => true
+    attribute :sign_request, Boolean, :default => true
+    attribute :endpoint, String
     
-    def get(path, headers={})
-      begin
-        response = RestClient.get(
-          "#{@server_url}#{path}", 
-          build_headers(:GET, "#{@url_path}#{path}", headers)
-        )
-        return Yajl.load(response.body)
-       
-      rescue => e
-        e.response
-      end
-    end
+    validates_presence_of :client_name, :key_file, :server_url
     
-    def post(path, payload, headers={})
-      begin
-        response = RestClient.post(
-          "#{@server_url}#{path}",
-          Yajl.dump(payload),
-          build_headers(:POST, "#{@url_path}#{path}", headers, Yajl.dump(payload))
-        )      
-        return Yajl.load(response.body)
-          
-      rescue => e
-        e.response
-      end
+    def connection
+      self
     end
     
-    def put(path, payload, headers={})
-      begin
-        response = RestClient.put(
-        "#{@server_url}#{path}",
-          Yajl.dump(payload),
-          build_headers(:PUT, "#{@url_path}#{path}", headers, Yajl.dump(payload))
-        )
-        return Yajl.load(response.body)
-        
-      rescue => e
-        e.response
-      end
+    def parsed_url
+      URI.parse(server_url)
     end
+
+    def get(path)
+      response = request(:headers => build_headers(
+        :GET, 
+        "#{parsed_url.path}#{path}")
+      ).get(
+        "#{server_url}#{path}"
+      )
+      return response
+    end # def get
     
-    def delete(path, headers={})
-      begin
-        response = RestClient.delete(
-        "#{@server_url}#{path}",
-          build_headers(:DELETE, "#{@url_path}#{path}", headers)
-        )
-        return Yajl.load(response.body)
-        
-      rescue => e
-        e.response
-      end
-    end  
+    def post(path, payload)
+      response = request(:headers => build_headers(
+        :POST, 
+        "#{parsed_url.path}#{path}", 
+        Yajl.dump(payload))
+      ).post(
+        "#{server_url}#{path}", 
+        Yajl.dump(payload)
+      )
+      return response
+    end # def post
     
-    def sign_requests?
-      auth_credentials.sign_requests? && @sign_request
-    end
+    def put(path, payload, headers={})
+      response = request(:headers => build_headers(
+        :PUT, 
+        "#{parsed_url.path}#{path}", 
+        Yajl.dump(payload))
+      ).put(
+        "#{server_url}#{path}", 
+        Yajl.dump(payload)
+      )
+      return response
+    end # def put
     
-    def search(index, options={})
-      Spice::Search.search(index, options)
-    end
+    def delete(path, headers={})
+      response = request(:headers => build_headers(
+        :DELETE, 
+        "#{parsed_url.path}#{path}")
+      ).delete(
+        "#{server_url}#{path}"
+      )
+      return response
+    end # def delete
     
     private
     
@@ -84,18 +97,20 @@ module Spice
         :http_method => method, 
         :path => path.gsub(/\?.*$/, ''),
         :body => json_body, 
-        :host => "#{@host}:#{@port}"
+        :host => "#{parsed_url.host}:#{parsed_url.port}"
       }
       request_params[:body] ||= ""
-      auth_credentials.signature_headers(request_params)
-    end
+      signature_headers(request_params)
+    end # def authentication_headers
     
-    def build_headers(method, path, headers={}, json_body=false)
-      headers['Accept']       = "application/json"
-      headers["Content-Type"] = 'application/json' if json_body
+    def build_headers(method, path, json_body=nil)
+      headers={}
+      # headers['Accept']       = "application/json"
+      # headers["Content-Type"] = 'application/json' if json_body
       headers['Content-Length'] = json_body.bytesize.to_s if json_body
       headers.merge!(authentication_headers(method, path, json_body)) if sign_requests?
       headers
-    end
-  end
-end
+    end # def build_headers
+
+  end # class Connection
+end # module Spice

data/lib/spice/connection/authentication.rb

@@ -0,0 +1,47 @@
+module Spice
+  class Connection
+    module Authentication
+
+      def sign_requests?
+        !!key_file
+      end
+
+      def signature_headers(request_params={})
+        load_signing_key if sign_requests?
+        request_params             = request_params.dup
+        request_params[:timestamp] = Time.now.utc.iso8601
+        request_params[:user_id]   = client_name
+        host = request_params.delete(:host) || "localhost"
+
+        sign_obj = Mixlib::Authentication::SignedHeaderAuth.signing_object(request_params)
+        signed = sign_obj.sign(@key).merge({:host => host})
+        signed.inject({}){|memo, kv| memo["#{kv[0].to_s.upcase}"] = kv[1];memo}
+        # Platform requires X-Chef-Version header
+        version = { "X-Chef-Version" => Spice.chef_version }
+        signed.merge!(version)      
+      end
+
+      private
+
+      def load_signing_key
+        begin
+          raw_key = File.read(key_file).strip
+        rescue SystemCallError, IOError => e
+          raise IOError, "Unable to read #{key_file}"
+        end
+        assert_valid_key_format!(raw_key)
+        @key = OpenSSL::PKey::RSA.new(raw_key)
+      end
+
+      def assert_valid_key_format!(raw_key)
+        unless (raw_key =~ /\A-----BEGIN RSA PRIVATE KEY-----$/) &&
+           (raw_key =~ /^-----END RSA PRIVATE KEY-----\Z/)
+          msg = "The file #{key_file} does not contain a correctly formatted private key.\n"
+          msg << "The key file should begin with '-----BEGIN RSA PRIVATE KEY-----' and end with '-----END RSA PRIVATE KEY-----'"
+          raise ArgumentError, msg
+        end
+      end
+      
+    end
+  end
+end

data/lib/spice/connection/clients.rb

@@ -0,0 +1,15 @@
+module Spice
+  class Connection
+    module Clients
+      def clients(options={})
+        connection.search('client', options)
+      end
+
+      def client(name)
+        attributes = connection.get("/clients/#{name}").body
+        Spice::Client.new(attributes)
+      end
+
+    end # module Clients
+  end # class Connection
+end # module Spice

data/lib/spice/connection/cookbooks.rb

@@ -0,0 +1,42 @@
+module Spice
+  class Connection
+    module Cookbooks
+      def cookbooks(options={})
+        if Gem::Version.new(Spice.chef_version) >= Gem::Version.new("0.10.0")
+          cookbooks = []
+          connection.get("/cookbooks").body.each_pair do |key, value|
+            versions = value['versions'].map{ |v| v['version'] }
+            cookbooks << Spice::Cookbook.new(:name => key, :versions => versions)
+          end
+          cookbooks
+        else
+          connection.get("/cookbooks").body.keys.map do |cookbook|
+            attributes = connection.get("/cookbooks/#{cookbook}").body.to_a[0]
+            Spice::Cookbook.new(:name => attributes[0], :versions => attributes[1])
+          end
+        end
+      end
+
+      def cookbook(name)
+        if Gem::Version.new(Spice.chef_version) >= Gem::Version.new("0.10.0")
+          cookbook = connection.get("/cookbooks/#{name}").body
+          puts cookbook[name]
+          versions = cookbook[name]['versions'].map{ |v| v['version'] }
+
+          Spice::Cookbook.new(:name => name, :versions => versions)
+        else
+          connection.get("/cookbooks").body.keys.map do |cookbook|
+            attributes = connection.get("/cookbooks/#{cookbook}").body.to_a[0]
+            Spice::Cookbook.new(:name => attributes[0], :versions => attributes[1])
+          end
+        end
+      end
+      
+      def cookbook_version(name, version)
+        attributes = connection.get("/cookbooks/#{name}/#{version}").body
+        Spice::CookbookVersion.new(attributes)
+      end
+      
+    end # module Cookbooks
+  end # class Connection
+end # module Spice

data/lib/spice/connection/data_bags.rb

@@ -0,0 +1,35 @@
+module Spice
+  class Connection
+    module DataBags
+      def data_bags
+        connection.get("/data").body.keys.map do |data_bag|
+          items = connection.search(data_bag)
+          Spice::DataBag.new(:name => data_bag, :items => items)
+        end
+      end
+
+      alias :data :data_bags
+      
+      def data_bag(name)
+        items = connection.search(name)
+        Spice::DataBag.new(:name => name, :items => items)
+      end
+
+      def data_bag_item(name, id)
+        data = connection.get("/data/#{name}/#{id}")
+        data.delete('id')
+        Spice::DataBagItem.new(:_id => id, :data => data, :name => name)
+      end
+
+      private
+
+      def get_data_bag_items(name)
+        connection.get("/data/#{name}").body.keys.map do |id|
+          data = connection.get("/data/#{name}/#{id}").body
+          Spice::DataBagItem.new(:_id => id, :data => data, :name => name)
+        end
+      end
+
+    end # module DataBags
+  end # class Connection
+end # module Spice

data/lib/spice/connection/environments.rb

@@ -0,0 +1,16 @@
+module Spice
+  class Connection
+    module Environments
+      def environments(options={})
+        connection.search('environment', options)
+      end
+
+      def environment(name)
+        attributes = connection.get("/environments/#{name}").body
+        attributes['attrs'] = attributes.delete('attributes')
+        Spice::Environment.new(attributes)
+      end
+
+    end # module Environments
+  end # class Connection
+end # module Spice

data/lib/spice/connection/nodes.rb

@@ -0,0 +1,15 @@
+module Spice
+  class Connection
+    module Nodes
+      def nodes(options={})
+        connection.search('node', options)
+      end
+
+      def node(name)
+        node_attributes = connection.get("/nodes/#{name}").body
+        Spice::Node.new(node_attributes)
+      end
+
+    end # module Nodes
+  end # class Connection
+end # module Spice

data/lib/spice/connection/roles.rb

@@ -0,0 +1,15 @@
+module Spice
+  class Connection
+    module Roles
+      def roles(options={})
+        connection.search('role', options)
+      end
+
+      def role(name)
+        attributes = connection.get("/roles/#{name}").body
+        Spice::Role.new(attributes)
+      end
+
+    end # module Roles
+  end # class Connection
+end # module Spice

data/lib/spice/connection/search.rb

@@ -0,0 +1,49 @@
+require 'cgi'
+
+module Spice
+  class Connection
+    module Search
+      def search(index, options={})
+        options = {:q => options} if options.is_a? String
+        options.symbolize_keys!
+
+        options[:q] ||= '*:*'
+        options[:sort] ||= "X_CHEF_id_CHEF_X asc"
+        options[:start] ||= 0
+        options[:rows] ||= 1000
+
+        # clean up options hash
+        options.delete_if{|k,v| !%w(q sort start rows).include?(k.to_s)}
+
+        params = options.collect{ |k, v| "#{k}=#{CGI::escape(v.to_s)}"}.join("&")
+        case index
+        when 'node'
+          connection.get("/search/#{CGI::escape(index.to_s)}?#{params}").body['rows'].map do |node|
+            Spice::Node.new(node)
+          end
+        when 'role'
+          connection.get("/search/#{CGI::escape(index.to_s)}?#{params}").body['rows'].map do |role|
+            Spice::Role.new(role)
+          end
+        when 'client'
+          connection.get("/search/#{CGI::escape(index.to_s)}?#{params}").body['rows'].map do |client|
+            Spice::Client.new(client)
+          end
+        when 'environment'
+          connection.get("/search/#{CGI::escape(index.to_s)}?#{params}").body['rows'].map do |env|
+            env['attrs'] = env.delete('attributes')
+            Spice::Environment.new(env)
+          end
+        else
+          # assume it's a data bag
+          connection.get("/search/#{CGI::escape(index.to_s)}?#{params}").body['rows'].map do |db|
+            data = db['raw_data']
+            id = data.delete('id')
+            Spice::DataBagItem.new(:_id => id, :data => data, :name => index)
+          end
+        end
+      end # def search
+      
+    end # module Search
+  end # class Connection
+end # module Spice

data/lib/spice/cookbook.rb

@@ -1,33 +1,16 @@
+require 'spice/persistence'
+
 module Spice
-  class Cookbook < Spice::Chef
-    def self.all(options={})
-      connection.get("/cookbooks")
-    end
-    
-    def self.[](name)
-      connection.get("/cookbooks/#{name}")
-    end
-    
-    def self.show(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.get("/cookbooks/#{name}")
-    end
-    
-    def self.create(options={})
-      connection.post("/cookbooks", options)
-    end
-    
-    def self.update(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.put("/cookbooks/#{name}", options)
-    end
-    
-    def self.delete(options={})
-      raise ArgumentError, "Option :name must be present" unless options[:name]
-      name = options.delete(:name)
-      connection.delete("/cookbooks/#{name}", options)
-    end
+  class Cookbook
+    include Toy::Store
+    include Spice::Persistence
+    extend Spice::Persistence
+    store :memory, {}
+    endpoint "cookbooks"
+
+    attribute :name, String
+    attribute :versions, Array, :default => []
+
+    validates_presence_of :name
   end
 end