updater 0.9.4 → 0.10.0

data/spec/schedule_spec.rb

@@ -2,16 +2,19 @@ require File.join( File.dirname(__FILE__),  "spec_helper" )
 
 include Updater
 
-require  File.join( File.dirname(__FILE__),  "fooclass" )
-
 describe "adding an immidiate update request" do
+  before :all do
+    @orm = Update.orm
+  end
+  
   before(:each) do
-    Foo.all.destroy!
+    Foo.reset
   end
-  it "with a class target" do
+  
+  specify "with a class target" do
     u = Update.immidiate(Foo,:bar,[])
     u.target.should == Foo
-    Update.current.get(u.id).should_not be_nil
+    @orm.current.should include(u.orm)
     Update.delayed.should == 0
   end
   
@@ -19,21 +22,26 @@ describe "adding an immidiate update request" do
     f = Foo.create
     u = Update.immidiate(f,:bar,[])
     u.target.should == f
-    Update.current.get(u.id).should_not be_nil
+    @orm.current.should include(u.orm)
     Update.delayed.should == 0
   end
   
   it "with an custome finder" do
     f = Foo.create(:name=>'baz')
+    Foo.should_receive(:first).with(:name=>'baz').and_return f
     u = Update.immidiate(Foo,:bar,[],:finder=>:first, :finder_args=>[{:name=>'baz'}])
     u.target.should == f
-    Update.current.get(u.id).should_not be_nil
+    @orm.current.should include(u.orm)
     Update.delayed.should == 0
   end
   
 end
 
 describe "chained request" do
+  before :all do
+    @orm = Update.orm
+  end
+  
   before :each do
     Update.clear_all
   end
@@ -41,7 +49,7 @@ describe "chained request" do
   it "should not be in current or delayed queue" do
     u = Update.chain(Foo,:bar,[:error])
     u.time.should be_nil
-    Update.current.should_not include(u)
+    @orm.current.should_not include(u.orm)
     Update.delayed.should == 0
   end
   
@@ -55,7 +63,7 @@ end
 describe "adding an delayed update request" do
   before :each do
     Update.clear_all
-    Foo.all.destroy
+    Foo.reset
   end
 
   
@@ -76,6 +84,7 @@ describe "adding an delayed update request" do
   
   it "with an custome finder" do
     f = Foo.create(:name=>'baz')
+    Foo.should_receive(:first).with(:name=>'baz').and_return f
     u = Update.at(Chronic.parse('tomorrow'),Foo,:bar,[],:finder=>:first, :finder_args=>[{:name=>'baz'}])
     u.target.should == f
     Update.current.should_not include(u)

data/spec/spec_helper.rb

@@ -4,20 +4,19 @@ ROOT = File.join(File.dirname(__FILE__), '..')
 $LOAD_PATH << File.join(File.dirname(__FILE__), '../lib')
 
 require "rspec" # Satisfies Autotest and anyone else not using the Rake tasks
-require "dm-core"
-require 'dm-migrations'
+#~ require "dm-core"
+#~ require 'dm-migrations'
 
 require 'updater'
 require 'updater/thread_worker'
 require 'updater/fork_worker'
-require 'updater/orm/datamapper'
+# require 'updater/orm/datamapper'
 
-Updater::Update.orm = Updater::ORM::DataMapper
+# Updater::Setup.test_setup(:database=>{:adapter=>'sqlite3', :database=>'./default.db', :auto_migrate=>true})
+Updater::Setup.test_setup
 
-DataMapper.setup(:default, 'sqlite3::memory:')
-DataMapper.auto_migrate!
+require  File.join( File.dirname(__FILE__),  "fooclass" )
+require  File.join( File.dirname(__FILE__),  "orm_lint" )
 
 require 'timecop'
 require 'chronic'
-
-

data/spec/thread_worker_spec.rb

@@ -17,43 +17,6 @@ describe ThreadWorker do
     ThreadWorker.new.name.should be_a String
   end
   
-  describe "loop thread control:" do
-    
-    class Foo
-      include DataMapper::Resource
-      
-      property :id, Serial
-      property :name, String
-      
-      def bar(*args)
-        Foo.bar(:instance,*args)
-      end
-      
-    end
-    
-    Foo.auto_migrate!
-    
-    specify "The loop should run when the worker is started" do
-      pending
-      worker = ThreadWorker.new(:quiet=>true, :name=>"testing")
-      Update.should_receive(:work_off).with(worker).once.and_return(nil)
-      t = Thread.new do
-        worker.start
-      end
-      t.run
-      worker.stop
-      t.kill unless t.join(0.1) #you've got 0.1 seconds to finish or die
-    end
-    
-    specify "The loop should run with USR1 signal" do
-      pending
-      t = Thread.new do
-        worker.start
-      end
-    end
-    
-  end
-  
 end
 
 describe "working off jobs:" do

data/spec/update_runner_spec.rb

@@ -2,13 +2,11 @@ require File.join( File.dirname(__FILE__),  "spec_helper" )
 
 include Updater
 
-require  File.join( File.dirname(__FILE__),  "fooclass" )
-
 describe "running an update" do
   
   before :each do
     Update.clear_all
-    Foo.all.destroy!
+    Foo.reset
   end
   
   it "should call the named method with a class target" do
@@ -28,21 +26,21 @@ describe "running an update" do
     u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
     Foo.should_receive(:bar).with(:arg1,:arg2)
     u.run
-    u.should_not be_saved #NOTE: not a theological statment
+    Update.orm.get(u.orm.id).should be_nil
   end
   
   it "should delete the record if there is a failure" do
     u = Update.immidiate(Foo,:bar,[:arg1,:arg2])
     Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
     u.run
-    u.should_not be_saved #NOTE: not a theological statment
+    Update.orm.get(u.orm.id).should be_nil
   end
   
   it "should NOT delete the record if it is a chain record" do
     u = Update.chain(Foo,:bar,[:arg1,:arg2])
     Foo.should_receive(:bar).with(:arg1,:arg2).and_raise(RuntimeError)
     u.run
-    u.should be_saved
+    Update.orm.get(u.orm.id).should_not be_nil
   end
   
 end

data/spec/update_spec.rb

@@ -7,7 +7,7 @@ describe Update do
     Updater::VERSION.should == File.read(File.join(ROOT,'VERSION')).strip
   end 
   
-  it "shuold have its own inspect method" do
+  it "should have its own inspect method" do
     Update.new(Update.orm.new).inspect.should =~ /Updater::Update/
   end
 

data/spec/util_spec.rb

@@ -1,7 +1,5 @@
 require File.join( File.dirname(__FILE__),  "spec_helper" )
 
-include Updater
-
 describe "Util.tempio" do
   
   it "should return an unlinked file" do

metadata

@@ -4,9 +4,9 @@ version: !ruby/object:Gem::Version
   prerelease: false
   segments: 
   - 0
-  - 9
-  - 4
-  version: 0.9.4
+  - 10
+  - 0
+  version: 0.10.0
 platform: ruby
 authors: 
 - John F. Miller
@@ -14,7 +14,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-02-14 00:00:00 -08:00
+date: 2011-03-06 00:00:00 -08:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -38,13 +38,13 @@ dependencies:
   requirement: &id002 !ruby/object:Gem::Requirement 
     none: false
     requirements: 
-    - - "="
+    - - ">="
       - !ruby/object:Gem::Version 
         segments: 
-        - 1
-        - 3
+        - 2
+        - 0
         - 0
-        version: 1.3.0
+        version: 2.0.0
   type: :development
   version_requirements: *id002
 - !ruby/object:Gem::Dependency 
@@ -93,29 +93,30 @@ files:
 - Rakefile
 - VERSION
 - lib/updater.rb
-- lib/updater/thread_worker.rb~
 - lib/updater/setup.rb
-- lib/updater/setup.rb~
 - lib/updater/util.rb
 - lib/updater/update.rb
 - lib/updater/fork_worker.rb
-- lib/updater/update_dm.rb
-- lib/updater/simulated.db
 - lib/updater/tasks.rb
 - lib/updater/thread_worker.rb
-- lib/updater/orm/mongo.rb~
 - lib/updater/orm/orm.rb
 - lib/updater/orm/datamapper.rb
+- lib/updater/orm/mock.rb
+- lib/updater/orm/activerocord.rb
 - lib/updater/orm/mongo.rb
+- spec/results.html
+- spec/datamapper_orm_spec.rb
 - spec/fork_worker_instance_spec.rb
 - spec/thread_worker_spec.rb
 - spec/schedule_spec.rb
-- spec/lock_spec.rb
-- spec/spec_helper.rb~
+- spec/mock_orm_spec.rb
 - spec/params_sub_spec.rb
 - spec/chained_spec.rb
+- spec/fooclass_spec.rb
 - spec/fooclass.rb
 - spec/update_spec.rb
+- spec/mongo_orm_spec.rb
+- spec/orm_lint.rb
 - spec/spec_helper.rb
 - spec/named_request_spec.rb
 - spec/update_runner_spec.rb

data/lib/updater/orm/mongo.rb~

@@ -1,188 +0,0 @@
-require 'mongo'
-require 'active_support/inflector' #to get classes from strings
-require 'active_support/core_ext/object/try'
-
-module Updater
-  module ORM
-    class Mongo
-      
-      FINDER= :get
-      ID=:_id
-      
-      def initialize(hash = {})
-        @hash = {}
-        hash.each do |key, val|
-          if respond_to? "#{key}="
-            send("#{key}=", val)
-          else
-            @hash[key] = val
-          end
-        end
-      end
-      
-      %w{time finder finder_args method method_args name persistance lock_name}.each do |field|
-        eval(<<-EOF)  #,__LINE__+1,__FILE__)
-          def #{field};@hash['#{field}'];end
-          def #{field}=(value);@hash['#{field}'] = value;end
-        EOF
-      end
-      
-      def _id
-        @hash['_id'] || @hash[:_id]
-      end
-      
-      def _id=(val)
-        val = BSON::ObjectID.from_string(val.to_s) unless val.kind_of? BSON::ObjectID
-        @hash[:_id] = val
-      end
-      
-      alias :id :_id
-      alias :'id=' :'_id='
-      
-      def target
-        @hash['target'].try :constantize
-      end
-      
-      def target=(value)
-        @hash['target'] = value.to_s
-      end
-      
-      def save
-        #todo validation
-        self.class.collection.save @hash
-      end
-      
-      def destroy
-        @collection.remove({:_id=>id})
-      end
-      
-      def [](arg)  #this allows easy mapping for time when a value coud either be U::ORM::Mongo or an ordered hash
-        @hash[arg]
-      end
-
-      #key :time, Integer, :numeric=>true
-      #key :target, String, :required => true
-      #key :finder, String
-     # key :finder_args, Array
-      #key :method, String :required => true
-      #key :method_args, String :required => true
-      #key :name
-     # key :persistant
-      #key :lock_name
-      
-      %w{failure success ensure}.each do |mode|
-        eval(<<-EOF) #,__FILE__,__LINE__+1)
-          def #{mode}
-            @#{mode} ||= init_chain(:#{mode})
-          end
-        EOF
-      end
-      
-      def init_chain(mode)
-        ret = [@hash[mode.to_s] || []].flatten
-        unless ret.empty?
-          ret = @collection.find(:_id=>{'$in'=>ret}).map {|i| self.class.new(i)}
-        end
-        ret.define_singleton_method '<<' do |val|
-          val = BSON::ObjectID.fron_string(val) if val.kind_of? String
-          aval,hval = case val
-            when self.class
-              [val,val.id]
-            when Hash
-              [self.class.new(val),val['_id']]
-            when BSON::ObjectID
-              [@collection.find_one(val),val]
-          end
-          @hash[mode] ||= []
-          @hash[mode] << hval
-          super aval
-        end
-      end
-      
-      def lock(worker)
-        raise NotImplimentedError, "Use lock_next"
-      end
-      
-      class << self
-        attr_accessor :db, :collection, :logger
-        
-        # Availible options:
-        # * :database - the name of the database *required*
-        # * :host - the host to connect to.  Default: "localhost"
-        # * :port - the port to connect to.  Default: 27017
-        # * :collection - which collection to store jobs in. Default: "Updater"
-        # * :username/:password - if these are present, they will be used to authenticate against the database
-        def setup(options)
-          logger = options[:logger]
-          raise ArgumentError, "Must spesify the name of a databas when setting up Mongo driver" unless options[:database]
-          logger.info "Attempting to connect to mongodb at #{[options[:host] || "localhost", options[:port] || 27017}
-          @db = ::Mongo::Connection.new(options[:host] || "localhost", options[:port] || 27017).db(options[:database].to_s)
-          if options[:username] && options[:password]
-            success = db.authenticate(options[:username] , options[:password])
-            raise RunTimeError, "Could not Authenticate with MongoDb \"#{options[:database]}\" Please check the username and password."
-          end
-          collection_name = options[:collection] || 'updater'
-          unless db.collection_names.include collection_name
-            logger.warn "Updater MongoDB Driver is creating a new collection, \"#{collection_name}\" in \"#{options[:database]}\""
-          end
-          @collection = db.collection(collection_name)
-        end
-        
-        def lock_next(worker)
-          hash = OrderedHash.new
-          hash['findandmodify'] =@collection.name
-          hash['query'] = {:time=>{'$lte'=>tnow},:lock_name=>nil}
-          hash['sort'] =[[:time,'ascending']] #oldest first
-          hash['update'] = {'$set'=>{:lock_name=>worker.name}}
-          hash['new'] = true
-          
-          ret = @db.command hash
-          return nil unless ret['ok'] == 1
-          return new(ret['value'])
-        end 
-        
-        def get(id)
-          id = BSON::ObjectID.from_string(id) if id.kind_of? String
-          new(@collection.find_one(id))
-        end
-        
-        def current
-          raise NotImplementedError, "Mongo does not support lazy evaluation"
-        end
-        
-        def current_load
-          @collection.find(:time=>{'$lte'=>tnow}).count
-        end
-        
-        def delayed
-          @collection.find(:time=>{'$gt'=>tnow}).count
-        end
-        
-        def future(start, finish)
-          @collection.find(:time=>{'$gt'=>start+tnow,'$lt'=>finish+tnow}).count
-        end
-        
-        def queue_time
-          nxt = @collection.find_one({:time=>{'$gt'=>3,'$lt'=>4}, :lock_name=>'foobar'}, :sort=>[[:time, :asc]], :fields=>[:time])
-          return nil unless nxt
-          return 0 if nxt['time'] <= tnow
-          return nxt['time'] - tnow
-        end
-        
-        def create(hash)
-          new(hash).save
-        end
-        
-        def clear_all
-          @collection.remove
-        end
-        
-        private
-        def tnow
-          Updater::Update.time.now.to_i
-        end
-      end
-      
-    end
-  end
-end

data/lib/updater/setup.rb~

@@ -1,175 +0,0 @@
-require 'logger'
-require 'yaml'
-require 'socket'
-require 'erb'
-
-module Updater
-  class Setup
-    class << self
-      def start
-        new(config_file).start
-      end
-      
-      def stop
-        new(config_file).stop
-      end
-      
-      def client_setup(options = {})
-        new(config_file, options).client_setup
-      end
-      
-      def monitor
-        
-      end
-          
-      def config_file(options = {})
-        if options[:config_file] && File.exists(options[:config_file])
-          option[:config_file]
-        elsif ENV['UPDATE_CONFIG'] && File.exists(ENV['UPDATE_CONFIG'])
-          ENV['UPDATE_CONFIG']
-        else
-          (Dir.glob('{config,.}/updater.config') + Dir.glob('.updater')).first
-        end
-      end
-    end
-    
-    ROOT = File.dirname(self.config_file || Dir.pwd)
-    
-    #extended used for clients who wnat to override parameters
-    def initialize(file_or_hash, extended = {})
-      @options = file_or_hash.kind_of?(Hash) ? file_or_hash : load_file(file_or_hash)
-      @options.merge!(extended)
-      @options[:pid_file] ||= File.join(ROOT,'updater.pid')
-      @options[:host] ||= "localhost"
-      @logger = @options[:logger] || Logger.new(@options[:log_file] || STDOUT)
-      level = Logger::SEV_LABEL.index(@options[:log_level].upcase) if @options[:log_level]
-      @logger.level = level || Logger::WARN unless @options[:logger] #only set this if we were not handed a logger
-    end
-    
-    def start
-      pid = Process.fork do
-        _start
-      end
-      @logger.warn "Successfully started Master Loop at pid #{pid}"
-      puts "Job Queue Processor Started at PID: #{pid}"
-    end
-    
-    def stop
-      Process.kill("TERM",File.read(@options[:pid_file]).to_i)
-    end
-    
-    # The client is responcible for loading classes and making connections.  We will simply setup the Updater spesifics
-    def client_setup
-      @logger.info "Updater Client is being initialized..."
-      set_orm
-      
-      if @options[:socket] && File.exists?(@options[:socket])
-        @logger.debug "Using UNIX Socket \"#{@options[:socket]}\""
-        Updater::Update.socket = UNIXSocket.new(@options[:socket])
-      elsif @options[:udp]
-        socket = UDPSocket.new()
-        socket.connect(@options[:host],@options[:udp])
-        Updater::Update.socket = socket
-      elsif @options[:tcp]
-        Updater::Update.socket = TCPSocket.new(@options[:host],@options[:tcp])
-      elsif @options[:remote]
-        raise NotImplimentedError #For future Authenticated Http Rest Server
-      end
-      
-      #set PID
-      if File.exists? @options[:pid_file]
-        Updater::Update.pid = File.read(@options[:pid_file]).strip
-      end
-      
-      
-    end
-    
-    private
-    
-    def set_orm
-      #don't setup twice.  Client setup might call this as part of server setup in which case it is already done
-      return false if Updater::Update.orm
-      orm = @options[:orm] || "datamapper"
-      @logger.info "Updater setting ORM to \"#{orm}\""
-      case orm.to_s.downcase
-        when "datamapper"
-          require 'updater/orm/datamapper'
-          Updater::Update.orm = ORM::DataMapper
-        when "mongodb"
-          require 'updater/orm/mongo'
-          Updater::Update.orm = ORM::Mongo
-        when "activerecord"
-          require 'updater/orm/activerecord'
-          Updater::Update.orm = ORM::ActiveRecord
-        else
-          require "update/orm/#{orm}"
-          Updater::Update.orm = Object.const_get("ORM").const_get(orm.capitalize)
-      end
-      @logger.info "Data store '#{orm}' selected"
-    end
-    
-    def _start
-      #set ORM
-      set_orm
-      #init DataStore
-      default_options = {:adapter=>'sqlite3', :database=>'./default.db'}
-      Updater::Update.orm.setup((@options[:database] || @options[:orm_setup] || default_options).merge(:logger=>@logger))
-      #load Models
-      
-      models = @options[:models] || Dir.glob('./app/models/**/*.rb')
-      models.each do |file|
-        require file
-      end
-      
-      #establish Connections
-      @options[:host] ||= 'localhost'
-      #Unix Socket -- name at @options[:socket]
-      if @options[:socket]
-        File.unlink @options[:socket] if File.exists? @options[:socket]
-        @options[:sockets] ||= []
-        @options[:sockets] << UNIXServer.new(@options[:socket])
-        @logger.info "Now listening on UNIX Socket: #{@options[:socket]}"
-      end
-      
-      #UDP potentially unsafe user monitor server for Authenticated Connections (TODO)
-      if @options[:udp]
-        @options[:sockets] ||= []
-        udp = UDPSocket.new
-        udp.bind(@options[:host],@options[:udp])
-        @options[:sockets] << udp
-        @logger.info "Now listening for UDP: #{@options[:host]}:#{@options[:udp]}"
-      end
-      
-      #TCP Unsafe user monitor server for Authenticated Connections (TODO)
-      if @options[:tcp]
-        @options[:sockets] ||= []
-        @options[:sockets] << TCPServer.new(@options[:host],@options[:tcp])
-        @logger.info "Now listening for TCP: #{@options[:host]}:#{@options[:tcp]}"
-      end
-      
-      #Log PID
-      File.open(@options[:pid_file],'w') { |f| f.write(Process.pid.to_s)}
-      
-      client_setup
-      
-      #start Worker
-      worker = @options[:worker] || 'fork'  #todo make this line windows safe
-      require "updater/#{worker}_worker"
-      worker_class = Updater.const_get("#{worker.capitalize}Worker")
-      worker_class.logger = @logger
-      @logger.info "Using #{worker_class.to_s} to run jobs:"
-      worker_class.start(@options)
-      File.unlink(@options[:pid_file])
-      File.unlink @options[:socket] if @options[:socket] && File.exists?(@options[:socket])
-    end
-    
-    def load_file(file)
-      return {} if file.nil?
-      file = File.open(file) if file.kind_of?(String)
-      @config_file = File.expand_path(file.path)
-      YAML.load(ERB.new(file.read).result(binding)) || {}
-    ensure
-      file.close if file.kind_of?(IO) && !file.closed?
-    end
-  end
-end