dm-chef-adapter 0.1.0 → 0.2.0

data/lib/dm-chef-adapter/adapter.rb

@@ -2,6 +2,7 @@ require 'json'
 require 'chef'
 require 'dm-core'
 require 'uuidtools'
+
 module DataMapper
   class Property
     class DocId < String
@@ -47,8 +48,10 @@ module DataMapper
             data = {"id" => resource.key.join('_')}
             data.merge! Chef::JSONCompat.from_json(resource.to_json)
             databag_item.raw_data = data
-            #binding.pry
             databag_item.create
+            if !@cache.nil?
+              @cache.delete(resource.class.storage_name)
+            end
           else
             raise "DataBagItem #{resource.class.storage_name}/#{resource.key.join('_')} already exists."
           end
@@ -81,6 +84,9 @@ module DataMapper
           databag_item = Chef::DataBagItem.load collection.storage_name, doc["id"]
           databag_item.raw_data.merge! Chef::JSONCompat.from_json(fields.to_json)
           databag_item.save
+          if !@cache.nil?
+            @cache.delete(collection.storage_name)
+          end
         end
       end
 
@@ -89,6 +95,9 @@ module DataMapper
         read(collection.query).each do |doc|
           databag_item = Chef::DataBagItem.load collection.storage_name, doc["id"]
           databag_item.destroy collection.storage_name, doc["id"]
+          if !@cache.nil?
+            @cache.delete(collection.storage_name)
+          end
         end
       end
 
@@ -107,9 +116,14 @@ module DataMapper
       def initialize(name, opts = {})
         super
         Chef::Config.configuration[:node_name] = opts["node_name"]
-	Chef::Config.configuration[:client_key] = opts["client_key"]
-	Chef::Config.configuration[:chef_server_url] = opts["chef_server_url"] if !opts["chef_server_url"].nil?
-        @chef = Chef::REST.new(Chef::Config[:chef_server_url])
+	      Chef::Config.configuration[:client_key] = opts["client_key"]
+	      Chef::Config.configuration[:chef_server_url] = opts["chef_server_url"] if !opts["chef_server_url"].nil?
+        if opts["memcache"]
+          require 'dalli'
+          @cache = Dalli::Client.new(opts["memcache_url"])
+        else
+          @cache = nil
+        end
         @uuid = UUIDTools::UUID
       end
 
@@ -139,15 +153,19 @@ module DataMapper
       #
       # @api private
       def records_for(model)
-	records = []
-	databag = chef_databag(model)
-	if !databag.nil?
+        if !@cache.nil?
+            return @cache.get(model) if !@cache.get(model).nil?
+        end
+	      records = []
+	      databag = chef_databag(model)
+ 	      if !databag.nil?
           chef_databag(model).keys.each do |key|
             records << Chef::DataBagItem.load(model, key).raw_data
           end
         end
-        records
-      end
+        @cache.set(model, records, 60) if !@cache.nil?
+        return records
+       end
 
       # Writes all records to a databag
       #

data/lib/dm-chef-adapter/adapter.rb~

@@ -0,0 +1,204 @@
+require 'json'
+require 'chef'
+require 'dm-core'
+require 'uuidtools'
+require 'pry'
+
+module DataMapper
+  class Property
+    class DocId < String
+      key true
+      writer false
+      default ''
+      # @api private
+      def to_child_key
+        Property::String
+      end
+
+    end # class DocId
+  end # module Property
+  module Is
+    module Chef
+      def is_chef(options={})
+        require 'dm-serializer'
+        property :id, DataMapper::Property::DocId
+      end
+    end
+  end
+  module Adapters
+    class ChefAdapter < AbstractAdapter
+      # @api semipublic
+      def create(resources)
+        resources.collect do |resource|
+          if !Chef::DataBag.list.keys.include?(resource.class.storage_name)
+	    databag = Chef::DataBag.new
+            databag.name resource.class.storage_name
+            databag.create
+          end
+          begin
+            resource.id = @uuid.sha1_create(
+              UUIDTools::UUID_DNS_NAMESPACE, 
+              ("%10.6f#{resource.class.storage_name}" % Time.now.to_f)
+            )
+          rescue
+            resource.send :instance_variable_set, :@id, resource.key
+          end
+          if !Chef::DataBag.load(resource.class.storage_name).keys.include?(resource.key.join('_'))
+            databag_item = Chef::DataBagItem.new
+            databag_item.data_bag resource.class.storage_name
+            data = {"id" => resource.key.join('_')}
+            data.merge! Chef::JSONCompat.from_json(resource.to_json)
+            databag_item.raw_data = data
+            databag_item.create
+          else
+            raise "DataBagItem #{resource.class.storage_name}/#{resource.key.join('_')} already exists."
+          end
+        end.count
+      end
+
+      # @api semipublic
+      def read(query)
+        records = records_for(query.model.storage_name)
+        ret = []
+        query.links.reverse.each do |link|
+          children = records_for(link.child_model.storage_name)
+          parents = records_for(link.parent_model.storage_name)
+          children.each do |child|
+            parents.each do |parent|
+              if child[link.child_key.first.name.to_s] == parent[link.parent_key.first.name.to_s]
+                records.each do |record|
+                  ret << child.merge(record)
+                end
+              end
+            end
+          end
+        end
+        query.filter_records(ret+records)
+      end
+
+      def update(attributes, collection)
+        fields = attributes_as_fields(attributes)
+        read(collection.query).each do |doc|
+          databag_item = Chef::DataBagItem.load collection.storage_name, doc["id"]
+          databag_item.raw_data.merge! Chef::JSONCompat.from_json(fields.to_json)
+          databag_item.save
+        end
+      end
+
+      # @api semipublic
+      def delete(collection)
+        read(collection.query).each do |doc|
+          databag_item = Chef::DataBagItem.load collection.storage_name, doc["id"]
+          databag_item.destroy collection.storage_name, doc["id"]
+        end
+      end
+
+      # @api semipublic
+      def attributes_as_fields(attributes)
+        pairs = attributes.map do |property, value|
+          dumped = value.kind_of?(Module) ? value.name : property.dump(value)
+          [ property.field, dumped ]
+        end
+        Hash[pairs]
+      end
+
+      private
+
+      # @api semipublic
+      def initialize(name, opts = {})
+        super
+        Chef::Config.configuration[:node_name] = opts["node_name"]
+	Chef::Config.configuration[:client_key] = opts["client_key"]
+	Chef::Config.configuration[:chef_server_url] = opts["chef_server_url"] if !opts["chef_server_url"].nil?
+        if !opts["cache"].nil?
+          Chef::Config.configuration[:dm_cache] = opts["cache"] 
+        else
+          Chef::Config.configuration[:dm_cache] = 60
+        end
+        @cache = {}
+        @chef = Chef::REST.new(Chef::Config[:chef_server_url])
+        @uuid = UUIDTools::UUID
+      end
+
+      # Retrieves all records for a model and yields them to a block.
+      #
+      # The block should make any changes to the records in-place. After
+      # the block executes all the records are dumped back to the databag.
+      #
+      # @param [Model, #to_s] model
+      #   Used to determine which file to read/write to
+      #
+      # @yieldparam [Hash]
+      #   A hash of record.key => record pairs retrieved from the databag
+      #
+      # @api private
+      def update_records(model)
+        records = records_for(model)
+        result = yield records
+        write_records(model, records)
+        result
+      end
+
+      # Read all records from a databag for a model
+      #
+      # @param [#storage_name] model
+      #   The model/name to retieve records for
+      #
+      # @api private
+      def records_for(model)
+        if !@cache[model].nil? && (Time.now - @cache[model][:timestamp]) < Chef::Config.configuration[:dm_cache]
+          return @cache[model][:records]
+        else
+	  records = []
+	  databag = chef_databag(model)
+ 	  if !databag.nil?
+            chef_databag(model).keys.each do |key|
+              records << Chef::DataBagItem.load(model, key).raw_data
+            end
+          end
+          @cache[model] = {}
+          @cache[model][:timestamp] = Time.now
+          @cache[model][:records] = records
+          return records
+        end
+      end
+
+      # Writes all records to a databag
+      #
+      # @param [#storage_name] model
+      #   The model/name to write the records for
+      #
+      # @param [Hash] records
+      #   A hash of record.key => record pairs to be written
+      #
+      # @api private
+      def write_records(model, records)
+        item = Chef::DataBagItem.load(model. records["id"])
+        item.from_hash records
+        item.save
+      end
+
+      # Given a model, gives the databag to be used for record storage
+      #
+      # @example
+      #   chef_databag(Article) #=> "Chef::DataBag"
+      #
+      # @param [#storage_name] model
+      #   The model to be used to determine the databag.
+      #
+      # @api private
+      def chef_databag(model)
+        begin
+          Chef::DataBag.load model
+        rescue
+          nil
+        end
+      end
+
+    end # class ChefAdapter
+
+    const_added(:ChefAdapter)
+  end # module Adapters
+  Model.append_extensions(Is::Chef)
+end # module DataMapper
+

data/lib/dm-chef-adapter/version.rb

@@ -1 +1 @@
-DMCHEFADAPTER_VERSION = "0.1.0"
+DMCHEFADAPTER_VERSION = "0.2.0"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: dm-chef-adapter
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-02-01 00:00:00.000000000Z
+date: 2012-03-07 00:00:00.000000000Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: chef
-  requirement: &81217850 !ruby/object:Gem::Requirement
+  requirement: &9732900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -21,10 +21,10 @@ dependencies:
         version: 0.10.8
   type: :runtime
   prerelease: false
-  version_requirements: *81217850
+  version_requirements: *9732900
 - !ruby/object:Gem::Dependency
   name: dm-core
-  requirement: &81217580 !ruby/object:Gem::Requirement
+  requirement: &9732400 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -32,10 +32,10 @@ dependencies:
         version: 1.2.0
   type: :runtime
   prerelease: false
-  version_requirements: *81217580
+  version_requirements: *9732400
 - !ruby/object:Gem::Dependency
   name: dm-serializer
-  requirement: &81217290 !ruby/object:Gem::Requirement
+  requirement: &9731940 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - =
@@ -43,7 +43,18 @@ dependencies:
         version: 1.2.1
   type: :runtime
   prerelease: false
-  version_requirements: *81217290
+  version_requirements: *9731940
+- !ruby/object:Gem::Dependency
+  name: dalli
+  requirement: &9731560 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *9731560
 description: uses chef databags as a backend for the datamapper ORM
 email:
 - ncethier@gmail.com
@@ -51,9 +62,10 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
+- lib/dm-chef-adapter.rb
 - lib/dm-chef-adapter/version.rb
 - lib/dm-chef-adapter/adapter.rb
-- lib/dm-chef-adapter.rb
+- lib/dm-chef-adapter/adapter.rb~
 - examples/blog.rb
 homepage: https://github.com/nickethier/dm-chef-adapter
 licenses:
@@ -77,7 +89,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.10
+rubygems_version: 1.8.15
 signing_key: 
 specification_version: 3
 summary: datamapper adapter to use a chef server as a datastore backend