dm-chef-adapter 0.1.0

data/examples/blog.rb

@@ -0,0 +1,43 @@
+require 'dm-core'
+require 'dm-chef-adapter'
+
+DataMapper.setup(:default, 
+  :adapter => 'chef', 
+  :node_name => "localbox", 
+  :client_key => "/path/to/client/key.pem", 
+  :chef_server_url => "http://chef.internal.net:4000/"
+)
+
+class Post
+  include DataMapper::Resource
+ 
+  is :chef
+ 
+  property :title,	String
+  property :body,	Text
+  property :published,	Boolean
+
+  has n, :comments
+end
+
+class Comment
+  include DataMapper::Resource
+
+  is :chef
+
+  property :created_by,	String
+  property :body,	Text
+  
+  belongs_to :post
+end
+
+DataMapper.finalize
+
+post = Post.new(:title => "Datamapper is Awesome", :body => "Lorem ipsum ...", :published => true);
+comment1 = Comment.new(:created_by => "Me", :body => "I agree")
+post.comments << comment1
+post.save
+
+
+
+  

data/lib/dm-chef-adapter.rb

@@ -0,0 +1 @@
+require 'dm-chef-adapter/adapter'

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

@@ -0,0 +1,190 @@
+require 'json'
+require 'chef'
+require 'dm-core'
+require 'uuidtools'
+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
+            #binding.pry
+            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?
+        @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)
+	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
+
+      # 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

@@ -0,0 +1 @@
+DMCHEFADAPTER_VERSION = "0.1.0"

metadata

@@ -0,0 +1,84 @@
+--- !ruby/object:Gem::Specification
+name: dm-chef-adapter
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Nick Ethier
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-02-01 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: chef
+  requirement: &81217850 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 0.10.8
+  type: :runtime
+  prerelease: false
+  version_requirements: *81217850
+- !ruby/object:Gem::Dependency
+  name: dm-core
+  requirement: &81217580 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *81217580
+- !ruby/object:Gem::Dependency
+  name: dm-serializer
+  requirement: &81217290 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - =
+      - !ruby/object:Gem::Version
+        version: 1.2.1
+  type: :runtime
+  prerelease: false
+  version_requirements: *81217290
+description: uses chef databags as a backend for the datamapper ORM
+email:
+- ncethier@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/dm-chef-adapter/version.rb
+- lib/dm-chef-adapter/adapter.rb
+- lib/dm-chef-adapter.rb
+- examples/blog.rb
+homepage: https://github.com/nickethier/dm-chef-adapter
+licenses:
+- Apache License (2.0)
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: datamapper adapter to use a chef server as a datastore backend
+test_files: []