vidibus-resource 0.2.1 → 0.3.1

data/Rakefile

@@ -1,25 +1,25 @@
-require "bundler"
-require "rdoc/task"
-require "rspec"
-require "rspec/core/rake_task"
+$:.unshift File.expand_path('../lib', __FILE__)
 
-Bundler::GemHelper.install_tasks
+require 'bundler'
+require 'rdoc/task'
+require 'rspec'
+require 'rspec/core/rake_task'
+require 'vidibus/resource/version'
 
-$LOAD_PATH.unshift File.expand_path("../lib", __FILE__)
-require "vidibus/resource/version"
+Bundler::GemHelper.install_tasks
 
 RSpec::Core::RakeTask.new(:rcov) do |t|
-  t.pattern = "spec/**/*_spec.rb"
+  t.pattern = 'spec/**/*_spec.rb'
   t.rcov = true
-  t.rcov_opts = ["--exclude", "^spec,/gems/"]
+  t.rcov_opts = ['--exclude', '^spec,/gems/']
 end
 
 Rake::RDocTask.new do |rdoc|
-  rdoc.rdoc_dir = "rdoc"
+  rdoc.rdoc_dir = 'rdoc'
   rdoc.title = "vidibus-sysinfo #{Vidibus::Resource::VERSION}"
-  rdoc.rdoc_files.include("README*")
-  rdoc.rdoc_files.include("lib/**/*.rb")
-  rdoc.options << "--charset=utf-8"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+  rdoc.options << '--charset=utf-8'
 end
 
 task :default => :rcov

data/app/controllers/api/resources_controller.rb

@@ -1,51 +1,88 @@
-# TODO: Split this file: one part for providers, one for consumers?
+# TODO: Split this file: one part for providers, one for consumers!
 class Api::ResourcesController < ApiController
   before_filter :ensure_klass
-  before_filter :find_instance
+  before_filter :ensure_instance, :unless => :no_instance_required?
 
-  # Creates resource consumer on provider.
+  # Creates resource consumer on provider or consumer.
+  # This action does not care if a resource already exists on consumer.
   def create
-    @instance.add_resource_consumer(params["service"])
-    render(:json => {:resource => JSON.generate(@instance.resourceable_hash)})
+    if provider?
+      instance.add_resource_consumer(params[:service], params[:realm])
+      render(:json => {:resource => JSON.generate(instance.resourceable_hash)})
+    else
+      if instance
+        instance.update_resource_attributes(params[:resource])
+      else
+        attributes = {:uuid => params[:uuid], :resource_attributes => JSON.parse(params[:resource])}
+        attributes[:realm_uuid] = params[:realm] if klass_with_realm?
+        klass.create!(attributes)
+      end
+      render(:nothing => true)
+    end
   end
 
   # Updates resource on consumer.
   def update
     begin
-      @instance.update_resource_attributes(params["resource"])
+      instance.update_resource_attributes(params['resource'])
       render :nothing => true
     rescue => e
-      Rails.logger.error 'Error while updating resource consumer: '+e.inspect
+      Rails.logger.error "Error while updating resource consumer:\n#{e.inspect}"
       render(:json => {:error => e}, :status => :bad_request)
     end
   end
 
-  # Removes a resource consumer from provider
-  # or remove a resource from a consumer.
+  # Removes a resource consumer from provider or consumer.
   def destroy
-    if @instance.respond_to?(:resource_consumers)
-      @instance.remove_resource_consumer(params["service"])
+    if provider?
+      instance.remove_resource_consumer(params[:service], params[:realm])
     else
-      @instance.destroy_without_callback
+      instance.destroy_without_callback
     end
-    render :nothing => true
+    render(:nothing => true)
   end
 
   private
 
-  def ensure_klass
-    begin
-      @klass = params[:klass].classify.constantize
+  def klass
+    @klass ||= begin
+      params[:klass].classify.constantize
     rescue => e
-      render :json => {:error => e}, :status => :bad_request
+      @klass_error = e
+    end
+  end
+
+  def klass_with_realm?
+    @is_klass_with_realm ||= klass.instance_methods.include?('realm_uuid')
+  end
+
+  def instance
+    @instance ||= begin
+      results = klass.where(:uuid => params[:uuid])
+      if klass_with_realm?
+        results = results.and(:realm_uuid => params[:realm])
+      end
+      results.first
     end
   end
 
-  def find_instance
-    result = @klass.where(:uuid => params[:uuid])
-    if @klass.new.respond_to?(:realm_uuid)
-      result.and(:realm_uuid => params[:realm])
+  def no_instance_required?
+    %w[create].include?(action_name) and !provider?
+  end
+
+  def ensure_klass
+    if !klass or @klass_error
+      render(:json => {:error => @klass_error}, :status => :bad_request)
+    end
+  end
+
+  def provider?
+    @is_provider ||= klass.instance_methods.include?('resource_consumers')
+  end
+
+  def ensure_instance
+    unless instance
+      render(:json => {:error => "#{klass} #{params[:uuid]} not found"}, :status => :not_found)
     end
-    @instance = result.first or render(:json => {:error => "#{@klass} #{params[:uuid]} not found"}, :status => :not_found)
   end
 end

data/lib/vidibus/resource/consumer/mongoid.rb

@@ -1,14 +1,12 @@
 module Vidibus::Resource
   module Consumer
-
-    class ConfigurationError < StandardError; end
+    class ConsumerError < Error; end
+    class ConfigurationError < ConsumerError; end
 
     module Mongoid
       extend ActiveSupport::Concern
 
       included do
-        include Vidibus::Uuid::Mongoid
-
         field :resource_attributes, :type => Hash, :default => {}
         field :uuid
         index :uuid
@@ -16,7 +14,7 @@ module Vidibus::Resource
 
         attr_accessor :extinct
 
-        before_create :add_resource_consumer
+        before_create :add_resource_consumer, :unless => :resource_attributes?
         before_save :set_resource_attributes
         before_destroy :remove_resource_consumer, :unless => :extinct
       end
@@ -24,38 +22,72 @@ module Vidibus::Resource
       # Registers this consumer with provider.
       def add_resource_consumer
         response = register_resource_consumer
-        self.resource_attributes = JSON.parse(response["resource"])
+        self.resource_attributes = JSON.parse(response['resource'])
         set_resource_attributes(true)
         true # ensure true!
       end
 
       # Removes this consumer from provider.
       def remove_resource_consumer
-        resource_provider.delete("/api/resources/#{self.class.to_s.tableize}/#{uuid}")
+        resource_provider.delete(resource_uri)
         true # ensure true!
       end
 
-      # Updates resource attributes.
+      # Updates resource attributes from given JSON data.
       # TODO: Update only data that has been changed.
-      def update_resource_attributes(data)
-        update_attributes(:resource_attributes => JSON.parse(data))
+      def update_resource_attributes(json)
+        update_attributes(:resource_attributes => JSON.parse(json))
       end
 
       # Returns a resource provider service.
       def resource_provider
         @resource_provider ||= begin
-          service = self.class.instance_variable_get("@resource_provider") or
+          service = self.class.instance_variable_get('@resource_provider') or
             raise ConfigurationError.new("No resource provider has been defined. Call #{self.class}.resource_provider(service, realm)")
-          realm = (self.class.instance_variable_get("@resource_realm") || try!(:realm_uuid)) or
-            raise ConfigurationError.new("No resource realm has been defined. Call #{self.class}.resource_realm(realm)")
+          realm = (self.class.instance_variable_get('@resource_realm') || try!(:realm_uuid)) or
+            raise ConfigurationError.new("No resource realm has been defined. Call #{self.class}.resource_realm(realm) or define the attribute :realm_uuid.")
           ::Service.discover(service, realm)
         end
       end
 
-      # Populates attributes of instance from
-      # received resource_attributes hash.
+      def destroy_without_callback
+        self.extinct = true
+        destroy
+      end
+
+      module ClassMethods
+
+        # Sets up resource provider service type and realm.
+        def resource_provider(service, realm = nil)
+          @resource_provider = service
+          resource_realm(realm) if realm
+        end
+
+        # Sets up realm of resource.
+        # If no realm has been set up class-wide, the attribute :realm_uuid will be used.
+        def resource_realm(realm)
+          @resource_realm = realm
+        end
+
+        # Ensures that an instance with given conditions exists.
+        def ensure!(conditions)
+          self.where(conditions).first || self.create!(conditions)
+        end
+
+        # Remove all intances with given conditions.
+        def remove(conditions)
+          existing = self.where(conditions).to_a
+          for instance in existing
+            instance.destroy
+          end
+        end
+      end
+
+      private
+
+      # Populates attributes of instance from resource_attributes hash.
       def set_resource_attributes(force = false)
-        if resource_attributes_changed? or force == true
+        if resource_attributes_changed? or new_record? or force == true
           for key, value in resource_attributes
             meth = key.to_s
 
@@ -90,42 +122,12 @@ module Vidibus::Resource
         true # ensure true!
       end
 
-      def destroy_without_callback
-        self.extinct = true
-        destroy
-      end
-
-      private
-
       def register_resource_consumer
-        resource_provider.post("/api/resources/#{self.class.to_s.tableize}/#{uuid}")
+        resource_provider.post(resource_uri)
       end
 
-      module ClassMethods
-
-        # Sets up resource provider service type and realm.
-        def resource_provider(service, realm = nil)
-          @resource_provider = service
-          resource_realm(realm) if realm
-        end
-
-        # Sets up realm of resource.
-        def resource_realm(realm)
-          @resource_realm = realm
-        end
-
-        # Ensures that an instance with given conditions exists.
-        def ensure!(conditions)
-          self.where(conditions).first || self.create!(conditions)
-        end
-
-        # Remove all intances with given conditions.
-        def remove(conditions)
-          existing = self.where(conditions).to_a
-          for instance in existing
-            instance.destroy
-          end
-        end
+      def resource_uri
+        @resource_uri ||= "/api/resources/#{self.class.to_s.tableize}/#{uuid}"
       end
     end
   end

data/lib/vidibus/resource/provider/mongoid.rb

@@ -1,67 +1,90 @@
-require "digest/md5"
+require 'digest/md5'
 
 module Vidibus::Resource
   module Provider
+    class ProviderError < Error; end
+    class ServiceError < ProviderError; end
+    class ConsumerNotFoundError < ProviderError; end
+
     module Mongoid
       extend ActiveSupport::Concern
 
       included do
-        field :resource_consumers, :type => Array, :default => []
+        field :resource_consumers, :type => Hash, :default => {}
         field :resourceable_hash_checksum, :type => Hash
 
         before_update :update_resource_consumers
         before_destroy :destroy_resource_consumers
+
+        scope :consumers_in_realm, lambda {|realm| where("resource_consumers.#{realm_uuid}" => {'$exists' => true})}
       end
 
       # Adds given resource consumer.
-      def add_resource_consumer(service_uuid)
-        list = resource_consumers || []
-        unless list.include?(service_uuid)
-          list << service_uuid
-          update_attributes(:resource_consumers => list.uniq)
+      def add_resource_consumer(service_uuid, realm_uuid)
+        self.resource_consumers ||= {}
+        self.resource_consumers[realm_uuid] ||= []
+        unless resource_consumers[realm_uuid].include?(service_uuid)
+          self.resource_consumers[realm_uuid] << service_uuid
+          create_resource_consumer(service_uuid, realm_uuid)
+          save
         end
       end
 
       # Removes given resource consumer.
-      def remove_resource_consumer(service_uuid)
-        self.resource_consumers.delete(service_uuid)
+      def remove_resource_consumer(service_uuid, realm_uuid)
+        unless resource_consumers[realm_uuid] and resource_consumers[realm_uuid].include?(service_uuid)
+          raise(ConsumerNotFoundError, "This resource has no consumer #{service_uuid} within realm #{realm_uuid}.")
+        end
+        destroy_resource_consumer(service_uuid, realm_uuid)
+        self.resource_consumers[realm_uuid].delete(service_uuid)
+        self.resource_consumers.delete(realm_uuid) if resource_consumers[realm_uuid].blank?
         save
       end
 
+      # TODO: Get rid of this! It's only for the controller...
       def resource_provider?
         true
       end
 
+      # TODO: Get rid of this! It's only for the controller...
       def resource_consumer?
         false
       end
 
-      # TODO: Handle attributes properly
       def resourceable_hash
-        attributes
+        @resourceable_hash ||= attributes.except('resource_consumers', '_id')
+      end
+
+      def resourceable_hash_json
+        @resourceable_hash_json ||= JSON.generate(resourceable_hash)
       end
 
       private
 
-      # Update resource consumers if significant changes were made.
+      def resource_uri
+        @resource_uri ||= "/api/resources/#{self.class.to_s.tableize}/#{uuid}"
+      end
+
+      # Performs given block on each resource consumer service.
+      def each_resource_consumer
+        resource_consumers.each do |realm_uuid, service_uuids|
+          service_uuids.each do |service_uuid|
+            yield(service_uuid, realm_uuid)
+          end
+        end
+      end
+
+      # Updates resource consumers if significant changes were made.
       # TODO: Send changes only (the resourceable ones)!
       # Performs update asynchronously.
       def update_resource_consumers
         return unless resource_consumers and resource_consumers.any?
-        return unless changes.except("resource_consumers", "updated_at").any?
-
-        hash = resourceable_hash
-        hash_checksum = Digest::MD5.hexdigest(hash.to_s)
-        unless hash_checksum == resourceable_hash_checksum
-          self.resourceable_hash_checksum = hash_checksum
-          uri = "/api/resources/#{self.class.to_s.tableize}/#{uuid}"
-          for service in resource_consumers
-            begin
-              ::Service.discover(service, realm_uuid).delay.put(uri, :body => {:resource => JSON.generate(hash)})
-            rescue => e
-              Rails.logger.error "An error occurred while updating resource consumer #{service}:"
-              Rails.logger.error e.inspect
-            end
+        return unless changes.except('resource_consumers', 'updated_at').any?
+
+        self.resourceable_hash_checksum = Digest::MD5.hexdigest(resourceable_hash_json)
+        if resourceable_hash_checksum_changed?
+          each_resource_consumer do |service_uuid, realm_uuid|
+            update_resource_consumer(service_uuid, realm_uuid)
           end
         end
       end
@@ -69,16 +92,32 @@ module Vidibus::Resource
       # Removes this resource from consumers.
       # Performs update asynchronously.
       def destroy_resource_consumers
-        for service in resource_consumers
-          begin
-            ::Service.discover(service, realm_uuid).delay.delete("/api/resources/#{self.class.to_s.tableize}/#{uuid}")
-          rescue => e
-            Rails.logger.error "An error occurred while destroying resource consumer #{service}:"
-            Rails.logger.error e.inspect
-            errors = true
-          end
+        each_resource_consumer do |service_uuid, realm_uuid|
+          destroy_resource_consumer(service_uuid, realm_uuid)
+        end
+      end
+
+      # Sends an API request to create the resource consumer.
+      def create_resource_consumer(service_uuid, realm_uuid)
+        resource_consumer_request(service_uuid, realm_uuid, :post, :body => {:resource => resourceable_hash_json})
+      end
+
+      # Sends an API request to update the resource consumer.
+      def update_resource_consumer(service_uuid, realm_uuid)
+        resource_consumer_request(service_uuid, realm_uuid, :put, :body => {:resource => resourceable_hash_json})
+      end
+
+      # Sends an API request to delete the resource consumer.
+      def destroy_resource_consumer(service_uuid, realm_uuid)
+        resource_consumer_request(service_uuid, realm_uuid, :delete)
+      end
+
+      def resource_consumer_request(service_uuid, realm_uuid, method, options = {})
+        begin
+          ::Service.discover(service_uuid, realm_uuid).delay.send(method, resource_uri, options)
+        rescue => e
+          raise(ServiceError, "Sending a #{method} request to the resource consumer #{service_uuid} within realm #{realm_uuid} failed!\n#{e.inspect}")
         end
-        true unless errors # ensure true!
       end
     end
   end

data/lib/vidibus/resource/version.rb

@@ -1,5 +1,5 @@
 module Vidibus
   module Resource
-    VERSION = "0.2.1"
+    VERSION = "0.3.1"
   end
 end

data/lib/vidibus/resource.rb

@@ -1,2 +1,8 @@
+module Vidibus
+  module Resource
+    class Error < StandardError; end
+  end
+end
+
 require "vidibus/resource/provider/mongoid"
 require "vidibus/resource/consumer/mongoid"

data/lib/vidibus-resource.rb

@@ -1,8 +1,11 @@
 require "json"
 require "rails"
+require "delayed_job"
+require "delayed_job_mongoid"
 require "vidibus-uuid"
 require "vidibus-secure"
 require "vidibus-api"
+require "vidibus-service"
 
 require "vidibus/resource"
 

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: vidibus-resource
 version: !ruby/object:Gem::Version 
-  hash: 21
+  hash: 17
   prerelease: 
   segments: 
   - 0
-  - 2
+  - 3
   - 1
-  version: 0.2.1
+  version: 0.3.1
 platform: ruby
 authors: 
 - Andre Pankratz
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-07-14 00:00:00 +02:00
+date: 2011-09-13 00:00:00 +02:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency