gom-script 0.1.2

data/.document

@@ -0,0 +1,5 @@
+README.rdoc
+lib/**/*.rb
+bin/*
+features/**/*.feature
+LICENSE

data/.gitignore

@@ -0,0 +1,7 @@
+*.sw?
+.DS_Store
+coverage
+rdoc
+pkg
+gom-script.gemspec
+tmp

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2009 art+com AG/dirk luesebrink
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.markdown

@@ -0,0 +1,31 @@
+# GOM Script
+
+Easy access over the wire to a remote GOM node. This gem includes a GNP
+callback server, support for automatic observer refreshments and command line
+tools for reading, writing and observing GOM entries.
+
+
+## Install
+    
+use the jewler tasks:
+
+    $ rake gemspec build install
+
+## Dependencies 
+
+## credits
+
+## Note on Patches/Pull Requests
+ 
+ * Fork the project.
+ * Make your feature addition or bug fix.
+ * Add tests for it. This is important so I don't break it in a
+   future version unintentionally.
+ * Commit, do not mess with rakefile, version, or history.
+   (if you want to have your own version, that is fine but
+    bump version in a commit by itself I can ignore when I pull)
+ * Send me a pull request. Bonus points for topic branches.
+
+## Copyright
+
+Copyright (c) 2009 art+com AG/dirk luesebrink. See LICENSE for details.

data/Rakefile

@@ -0,0 +1,67 @@
+require 'rubygems'
+require 'rake'
+
+begin
+  require 'jeweler'
+  Jeweler::Tasks.new do |gem|
+    # gem is a Gem::Specification... see
+    # http://www.rubygems.org/read/chapter/20 for additional settings
+    #
+    gem.name = "gom-script"
+    gem.summary = %Q{connecting scripts and daemons with a remote GOM instance}
+    gem.description = %Q{ 
+      GOM is a schema-less object database in ruby with Resource Oriented API,
+      server-side javascript, distributed HTTP notifications and some more.
+      This gom-script script simplifies coding of clients and daemon which like
+      to listen on state change event in the GOM.
+    }.gsub /\n\n/, ''
+    gem.email = "dirk.luesebrink@gmail.com"
+    gem.homepage = "http://github.com/crux/gom-script"
+    gem.authors = ["art+com/dirk luesebrink"]
+    gem.add_runtime_dependency "applix", ">=0.2.1"
+    gem.add_runtime_dependency "rack"
+    gem.add_runtime_dependency "gom-core"
+
+    gem.add_development_dependency "rspec"
+    gem.add_development_dependency "fakeweb", ">=1.2.7"
+  end
+rescue LoadError
+  puts "Jeweler (or a dependency) not available. Install it with: sudo gem install jeweler"
+end
+
+require 'spec/rake/spectask'
+desc "Run all specs in spec directory"
+Spec::Rake::SpecTask.new(:spec) do |t|
+  t.spec_files = FileList['spec/**/*_spec.rb']
+  t.spec_opts = %w(-c)
+end
+
+begin
+  require 'rcov/rcovtask'
+  Rcov::RcovTask.new do |test|
+    test.libs << 'test'
+    test.pattern = 'spec/**/*_spec.rb'
+    test.verbose = true
+  end
+rescue LoadError
+  task :rcov do
+    abort "RCov is not available. In order to run rcov, you must: sudo gem install spicycode-rcov"
+  end
+end
+
+require 'rake/rdoctask'
+Rake::RDocTask.new do |rdoc|
+  if File.exist?('VERSION')
+    version = File.read('VERSION')
+  else
+    version = ""
+  end
+
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title = "GOM Remote - #{version}"
+  rdoc.rdoc_files.include('README*')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+task :test => :check_dependencies
+task :default => :spec

data/VERSION

@@ -0,0 +1 @@
+0.1.2

data/lib/gom-script.rb

@@ -0,0 +1 @@
+require 'gom/remote'

data/lib/gom/remote.rb

@@ -0,0 +1,8 @@
+require 'rubygems'
+require 'gom-core'
+require 'gom/remote/connection'
+require 'gom/remote/entry'
+require 'gom/remote/subscription'
+#require 'gom/remote/callback_server'
+require 'gom/remote/http_server'
+require 'gom/remote/daemon'

data/lib/gom/remote/connection.rb

@@ -0,0 +1,194 @@
+require 'net/http'
+require 'open-uri'
+require 'json'
+
+module Gom
+  module Remote
+
+    class << self; attr_accessor :connection; end
+
+    class Connection
+
+      attr_reader :target_url, :initial_path, :callback_server
+
+      class << self
+        # take apart the URL into GOM and node path part
+        def split_url url
+          u = URI.parse url
+          re = %r|#{u.scheme}://#{u.host}(:#{u.port})?|
+            server = (re.match url).to_s
+          path = (url.sub server, '').sub(/\/$/, '')
+          [server, path]
+        end
+
+        def init url, callback_port = nil
+          connection = (self.new url, callback_port)
+          [connection, connection.initial_path]
+        end
+      end
+
+      # url: initial GOM url, path or attribute. The remote GOM server
+      # address gets extracted from this and, unless nil, the given block
+      # will be called with the remaining GOM path, aka:
+      #
+      #   url == http://gom:1234/foo/bar:attribute 
+      #
+      # will use 'http://gom:1234' as GOM server and call the block with
+      # '/foo/bar:attribute' as path argument.
+      #
+      def initialize url, callback_port = nil
+        @target_url, @initial_path = (Connection.split_url url)
+        #Gom::Remote.connection and (raise "connection already open")
+        Gom::Remote.connection = self
+
+        @subscriptions = []
+        @callback_server = init_callback_server callback_port
+      end
+
+      def write path, value
+        if value.kind_of? Hash 
+          write_node path, attributes
+        else
+          write_attribute path, value
+        end
+      end
+
+      def write_attribute path, value
+        # TODO: Primitive#encode returns to_s for all unknow types. exception
+        # would be correct.
+        txt, type = (Gom::Core::Primitive.encode value)
+        params = { "attribute" => txt, "type" => type }
+        url = "#{@target_url}#{path}"
+        http_put(url, params)
+      end
+      
+      def write_node path, attributes
+        raise "not yet implemented"
+      end
+
+      def read path
+        url = "#{@target_url}#{path}"
+        open(url).read
+      rescue Timeout::Error => e
+        raise "connection timeout: #{url}"
+      rescue OpenURI::HTTPError => e
+        case code = e.to_s.to_i rescue 0
+        when 404
+          raise NameError, "undefined: #{path}"
+        else
+          puts " ## gom connection error: #{url} -- #{e}"
+          throw e
+        end
+      rescue => e
+        puts " ## read error: #{url} -- #{e}"
+        throw e
+      end
+
+      # update subscription observers. GNP callbacks will look like:
+      # 
+      #   http://<callback server>:<callback port>/gnp;<subscription name>;<subscription path>
+      #
+      def refresh
+        puts " -- refresh subscriptions(#{@subscriptions.size}):"
+
+        run_callback_server # call it once to make sure it runs
+        
+        @subscriptions.each do |sub| 
+          puts "     - #{sub.name}"
+          params = { "attributes[accept]" => 'application/json' }
+
+          query = "/gnp;#{sub.name};#{sub.entry_uri}"
+          params["attributes[callback_url]"] = "#{callback_server.base_url}#{query}"
+
+          [:operations, :uri_regexp, :condition_script].each do |key|
+            (v = sub.send key) and params["attributes[#{key}]"] = v
+          end
+
+          url = "#{@target_url}#{sub.uri}"
+          http_put(url, params) # {|req| req.content_type = 'application/json'}
+        end
+      end
+
+      def subscribe sub
+        @subscriptions.delete sub # every sub only once!
+        @subscriptions.push sub
+      end
+
+      private
+
+      def init_callback_server port
+        txt = (read "/gom/config/connection.txt")
+        unless m = (txt.match /^client_ip:\s*(\d+\.\d+\.\d+\.\d+)/) 
+          raise "/gom/config/connection: No Client IP? '#{txt}'"
+        end
+        # this is the IP by which i am seen from the GOM 
+        ip = m[1]
+
+        http = (HttpServer.new :host => ip, :port => port)
+        http.mount "^/gnp;", lambda {|*args| gnp_handler *args}
+
+        http
+      end
+
+      def run_callback_server
+        callback_server.start unless callback_server.running? 
+      end
+
+      #def gnp_callback name, entry_uri, req
+      def gnp_handler request_uri, env
+        op, name, entry_uri = (request_uri.to_s.split /;/)
+        unless sub = @subscriptions.find { |s| s.name == name }
+          raise "no such subscription: #{name} :: #{entry_uri}"#\n#{@subscriptions.inspect}"
+        end
+
+        begin
+          req = Rack::Request.new(env)
+          op, payload = (decode_gnp_body req.body.read)
+          (sub.callback.call op, payload)
+        rescue Exception => e
+          callstack = "#{e.backtrace.join "\n    "}"
+          puts " ## Subscription::callback - #{e}\n -> #{callstack}"
+        end 
+
+        # HTTP OK keeps the subscription alive, even in case of handler errors
+        [200, {"Content-Type"=>"text/plain"}, ["keep going dude!"]]
+      end
+
+      def decode_gnp_body txt
+        debugger if (defined? debugger)
+        json = (JSON.parse txt)
+        puts " -- json GNP: #{json.inspect}"
+
+        payload = nil
+        op = %w{update delete create}.find { |op| json[op] }
+        %w{attribute node}.find { |t| payload = json[op][t] }
+        #puts "payload: #{payload.inspect}"
+        [op, payload]
+
+        #op = (json.include? 'update') ? :udpate : nil
+        #op ||= (json.include? 'delete') ? :delete : nil
+        #op ||= (json.include? 'create') ? :create : nil
+        #op or (raise "unknown GNP op: #{txt}") 
+
+        #payload = json[op.to_s]
+        #[op, (payload['attribute'] || payload['node'])]
+      end
+
+      # incapsulates the underlying net access
+      def http_put(url, params, &request_modifier)
+        uri = URI.parse url
+        req = Net::HTTP::Put.new uri.path
+        req.set_form_data(params)
+        request_modifier && (request_modifier.call req)
+
+        session = (Net::HTTP.new uri.host, uri.port)
+        case res = session.start { |http| http.request req }
+        when Net::HTTPSuccess, Net::HTTPRedirection
+          # OK
+        else
+          res.error!
+        end
+      end
+    end
+  end
+end

data/lib/gom/remote/daemon.rb

@@ -0,0 +1,78 @@
+require 'timeout'
+module Gom
+  module Remote
+    class Daemon
+
+      include ::Timeout
+
+      Defaults = { 
+        :actor_dt       => 60,
+        :sensor_dt      => 1,
+        :callback_port  => 8815,
+        :stealth        => false,
+      }
+
+      include OAttr
+      oattr :actor_dt, :sensor_dt, :stealth
+
+      # service_path is derived from the service_url (server part stripped)
+      attr :service_path
+
+      def initialize service_url, options = {}, &blk
+        @options = (Defaults.merge options)
+        callback_port = @options[:callback_port]
+        @gom, @service_path = (Connection.init service_url, callback_port)
+        (blk.call self, @service_path) unless blk.nil?
+      end
+
+=begin
+      def open_nagios_port jjjjj
+        @gom.callback_server.mount(%r{^/nagios}, lambda do |*args|
+          uri, env = *args
+          req = Rack::Request.new(env)
+          envmap = (env.map { |k,v| "#{k}: #{v}" }.join "\n")
+          body = ["OK -- #{env['REQUEST_URI']}\n---\n#{envmap}"]
+          [200, {"Content-Type"=>"text/plain"}, body]
+        end)
+      end
+          hs = HttpServer.new o 
+          hs.mount "^/gnp;", lambda {|*args| gnp_handler *args}
+=end
+      def sensor_loop interval = sensor_dt, &tic
+        puts " -- running gom-script sensor loop.."
+        forever(interval) { tic.call self }
+      end
+
+      def actor_loop interval = actor_dt, &tic
+        puts " -- running gom-script actor loop.."
+        forever(interval) do 
+          @gom.refresh
+          tic && (tic.call self) || :continue
+        end
+      end
+
+      def forever interval = 0, &callback 
+        loop do
+          begin
+            rc = callback.call
+          rescue Exception => e
+            puts " ## <#{e.class}> #{self} - #{e}\n -> #{e.backtrace.join "\n    "}"
+          ensure
+            break if rc == :stop
+            sleep interval
+          end
+        end
+      end
+
+      # push own ip and monitoring port back to GOM node
+      def check_in
+        if stealth
+          puts " -- no GOM check-in in stealth mode"
+        else
+          @gom.write "#{service_path}:daemon_ip", @gom.callback_server.host
+          #@gom.write "#{service_path}:nagios_port", nagios_port
+        end
+      end
+    end
+  end
+end

data/lib/gom/remote/entry.rb

@@ -0,0 +1,27 @@
+module Gom
+  module Remote
+    class Entry
+      include Gom::Remote
+      def gom 
+        Gom::Remote.connection
+      end
+      # @deprecated?
+      def connection 
+        Gom::Remote.connection
+      end
+
+      def gnode path
+        json = (connection.read "#{path}.json")
+        (JSON.parse json)["node"]["entries"].select do |entry|
+          # 1. select attribute entries
+          entry.has_key? "attribute"
+        end.inject({}) do |h, a|
+            # 2. make it a key, value list
+            h[a["attribute"]["name"].to_sym] = a["attribute"]["value"]
+            h
+        end
+      end
+    end
+  end
+end
+

data/lib/gom/remote/http_server.rb

@@ -0,0 +1,124 @@
+require 'rack'
+require 'rack/handler/mongrel'
+require 'thread'
+require 'applix/oattr'
+
+module Gom
+  module Remote
+    class HttpServer
+
+      Defaults = {
+        :host => "0.0.0.0", :port => 25191
+      }
+
+      include OAttr
+      oattr :host, :port
+
+      def initialize options = {}
+        @options = (Defaults.merge options)
+        @mounts = {}
+        @mounts_access = Mutex.new
+      end
+
+      def base_url
+        p = (port == 80 ? '' : ":#{port}")
+        "http://#{host}#{p}"
+      end
+
+      def running?
+        !@server.nil?
+      end
+
+      def mount pattern, handler
+        @mounts_access.synchronize { @mounts.update pattern => handler }
+        self
+      end
+
+      def unmount pattern
+        @mounts_access.synchronize { @mounts.delete pattern }
+        self
+      end
+
+      def start
+        @server.nil? or (raise "already running!")
+        @thread = Thread.new { start_mongrel_server }
+        sleep 0.1 # give thread time for start-up
+        @thread
+      end
+
+      def stop
+        @server.nil? and (raise "not running!")
+        puts ' -- stopping callback server..'
+        @server.stop
+        @server = nil
+        puts '    down.'
+        sleep 2 # sleep added as a precaution 
+        puts ' -- killing server thread now...'
+        @thread.kill
+        @thread = nil
+        puts '    and gone.'
+        self
+      end
+
+      # take the URI on walk it through the list of mounts and return the one
+      # with the longest match or nil. In case of a match the corresponding
+      # handler is returned, nil otherwise.
+      def match uri
+        targets = []
+        @mounts_access.synchronize do
+          targets = @mounts.map do |re, app|
+            [app, (uri.path.match re).to_s]
+          end
+        end
+
+        # sort for longest match. And target might be nil already for an empty
+        # targets list, which is ok as we return nil in that case.
+        target = targets.sort!{|a,b| a[1].length <=> b[1].length}.last
+        func, pattern = target
+        (pattern.nil? || pattern.empty?) ? nil : func
+      end
+
+      private
+
+      # dispatching a request URI from env['REQUEST_URI'] which look
+      # somethings like: 
+      # 
+      #   http://172.20.2.9:2719/gnp;enttec-dmx;/services/enttec-dmx-usb-pro/values
+      #
+      def dispatch env
+        #req = Rack::Request.new(env)
+        uri = (URI.parse env['REQUEST_URI'])
+        if func = (match uri)
+          func.call uri, env
+        else
+          puts " !! no handler for: #{req.fullpath} -- #{@mounts.keys.inspect}"
+          [404, {"Content-Type"=>"text/plain"}, ["Not Found"]]
+        end
+      rescue => e
+        puts " ## #{e}\n -> #{e.backtrace.join "\n    "}"
+        [500, {"Content-Type"=>"text/plain"}, [e]]
+      end
+
+      # as i absolutly dislike capitalized options i use lowercase options
+      # throughout and only convert them just before i pass them the the
+      # mongrel server. Nothing to be proud of, but i definitly don't want to
+      # write --Port on the command line...
+      def mongrel_opts
+        @options.merge :Host => @options[:host], :Port => @options[:port]
+      end
+
+      def start_mongrel_server
+        puts " -- starting http server: #{@options.inspect}"
+        @server.nil? or (raise "already running!")
+        f = Proc.new {|env| dispatch env}
+        Rack::Handler::Mongrel.run(f, mongrel_opts) do |server|
+          @server = server
+          puts "    mongrel up: #{@options.inspect}"
+        end
+      rescue Exception => e
+        puts " ## oops: #{e}"
+        puts @options.inspect
+      end
+    end
+  end
+end

data/lib/gom/remote/subscription.rb

@@ -0,0 +1,38 @@
+module Gom
+  module Remote
+    class Subscription
+      
+      Defaults = {
+        :name             => nil,
+        :operations       => [:update],
+        :condition_script => nil, 
+        :uri_regexp       => nil,
+        :callback         => nil, 
+      }
+
+      attr_reader :entry_uri, :uri, :callback
+      attr_accessor :callback
+      attr_reader :name, :operations, :condition_script, :uri_regexp
+
+      def to_s
+        "#{self.class}: #{@options.inject}"
+      end
+
+      # hint: supplying a recognizable name helps with distributed gom
+      # operations 
+      #
+      def initialize entry_uri, options = {}, &blk
+        @name = options[:name] || "0x#{object_id}"
+        # URI for the observer node 
+        @uri = "/gom/observer#{entry_uri.sub ':', '/'}/.#{@name}"
+
+        @options = Defaults.merge options
+        @entry_uri = entry_uri
+        @callback = options[:callback] || blk;
+        @operations = (@options[:operations] || []).join ', '
+        @uri_regexp = (re = @options[:uri_regexp]) && (Regexp.new re) || nil
+        @condition_script = @options[:condition_script]
+      end
+    end
+  end
+end

data/spec/gom/remote/connection_spec.rb

@@ -0,0 +1,109 @@
+require File.dirname(__FILE__)+'/../../spec_helper'
+
+describe Gom::Remote::Connection do
+
+  describe "initialization" do
+    it "should split a GOM node url" do
+      gom, path = (Gom::Remote::Connection.split_url 'http://gom:345/dmx/node')
+      gom.should == 'http://gom:345'
+      path.should == '/dmx/node'
+    end
+    it "should strip last slash from the node" do
+      gom, path = (Gom::Remote::Connection.split_url 'http://xxx:4321/a/b/c/')
+      gom.should == 'http://xxx:4321'
+      path.should == '/a/b/c'
+      gom, path = (Gom::Remote::Connection.split_url 'http://xxx:4321/a/b:c/')
+      gom.should == 'http://xxx:4321'
+      path.should == '/a/b:c'
+    end
+    it "should split an attribute URL" do
+      gom, path = (Gom::Remote::Connection.split_url 'http://xxx/a:x')
+      gom.should == 'http://xxx'
+      path.should == '/a:x'
+    end
+    it "should split a GOM node url on init" do
+      gom, path = (Gom::Remote::Connection.init 'http://gom:345/dmx/node')
+      gom.target_url.should == 'http://gom:345'
+      path.should == '/dmx/node'
+    end
+  end
+
+  describe "with a connection it" do
+    before :each do
+      @gom, path = (Gom::Remote::Connection.init 'http://gom:345/dmx/node')
+    end
+
+    it "should fetch the callback_ip from remote" do
+      @gom.callback_server.host.should == "10.0.0.23"
+    end
+
+    it "should put attribute values to remote" do
+      @gom.should_receive(:http_put).
+        with("http://gom:345/some/node:attr", { "attribute" => "abc", "type" => :string })
+      @gom.write '/some/node:attr', "abc"
+    end
+  end
+
+  describe "with subscriptions" do 
+    before :each do
+      @gom, path = (Gom::Remote::Connection.init 'http://localhost:3000')
+      @gom.stub!(:run_callback_server).and_return(true)
+    end
+
+    #it "should have no subscriptions on init" do
+    #  @gom.subscriptions.should == []
+    #end
+
+    it "should subscribe operations whitelist" do
+      s = (Gom::Remote::Subscription.new '/node', :operations => [:delete, :create])
+      @gom.should_receive(:http_put).with(
+        "http://localhost:3000/gom/observer/node/.#{s.name}", 
+        hash_including("attributes[operations]" => 'delete, create')
+      )
+      @gom.subscribe s
+      @gom.refresh
+    end
+
+    it "should have an uri regexp" do
+      s = (Gom::Remote::Subscription.new '/node', :uri_regexp => /foo/)
+      @gom.should_receive(:http_put).with(
+        "http://localhost:3000/gom/observer/node/.#{s.name}", 
+        hash_including("attributes[uri_regexp]" => /foo/)
+      )
+      @gom.subscribe s
+      @gom.refresh
+    end
+
+    it "should have accept=application/json param" do
+      s = (Gom::Remote::Subscription.new '/node')
+      @gom.should_receive(:http_put).with(
+        "http://localhost:3000/gom/observer/node/.#{s.name}", 
+        hash_including("attributes[accept]" => 'application/json')
+      )
+      @gom.subscribe s
+      @gom.refresh
+    end
+
+    it "should put observer to gom on refresh" do
+      s = (Gom::Remote::Subscription.new '/node/values')
+      @gom.should_receive(:http_put).with(
+        "http://localhost:3000/gom/observer/node/values/.#{s.name}", 
+        #hash_including("attributes[callback_url]" => "http://1.2.3.4:2179/gnp;#{s.name};/node/values") 
+        hash_including("attributes[callback_url]" => anything)
+      )
+      @gom.subscribe s
+      @gom.refresh
+    end
+
+    it "should observe an attribute entry" do
+      s = (Gom::Remote::Subscription.new '/node:attribute')
+      @gom.should_receive(:http_put).with(
+        "http://localhost:3000/gom/observer/node/attribute/.#{s.name}", 
+        #hash_including("attributes[callback_url]" => "http://1.2.3.4:2179/gnp;#{s.name};/node:attribute") 
+        hash_including("attributes[callback_url]" => anything)
+      )
+      @gom.subscribe s
+      @gom.refresh
+    end
+  end
+end

data/spec/gom/remote/daemon_spec.rb

@@ -0,0 +1,57 @@
+require File.dirname(__FILE__)+'/../../spec_helper'
+
+include Gom::Remote
+
+describe Gom::Remote::Daemon do
+
+  describe "with a plain vanilla daemon" do
+    before :each do
+      @daemon = Daemon.new 'http://gom:345/gom-script/test'
+    end
+    it "should have a default actor_dt" do
+      @daemon.actor_dt.should == Daemon::Defaults[:actor_dt]
+    end
+    it "should have stealth mode off by default" do
+      @daemon.stealth.should == false
+    end
+    it "should have a default sensor_dt" do
+      @daemon.sensor_dt.should == Daemon::Defaults[:sensor_dt]
+    end
+
+    it "should parse the service_path from the service_url" do
+      @daemon.service_path.should == '/gom-script/test'
+    end
+    it "should terminate sensor loop on :stop" do
+      count = 0
+      timeout(1) do
+        @daemon.sensor_loop(0.1) { count += 1; :stop if count == 3 }
+      end
+      count.should == 3
+    end
+    it "should terminate actor loop on :stop" do
+      Gom::Remote.connection.should_receive(:refresh)
+      timeout(1) { @daemon.actor_loop { :stop } }
+    end
+
+    it "should check in with its client ip" do
+      Gom::Remote.connection.should_receive(:write).
+        with("/gom-script/test:daemon_ip", "10.0.0.23")
+      @daemon.check_in
+    end
+  end
+
+  describe "initialization" do
+    it "should find the class" do
+      Daemon.should_not == nil
+    end
+
+    it "should init the connection" do
+      Gom::Remote.connection.should == nil
+      Daemon.new 'http://gom:345/gom-script/test'
+      (c = Gom::Remote.connection).should_not == nil
+      c.target_url.should == 'http://gom:345'
+      c.initial_path.should == '/gom-script/test'
+      c.callback_server.port.should == Daemon::Defaults[:callback_port]
+    end
+  end
+end

data/spec/gom/remote/http_server_spec.rb

@@ -0,0 +1,106 @@
+require File.dirname(__FILE__)+'/../../spec_helper'
+
+describe Gom::Remote::HttpServer do
+
+  describe "initialization" do
+    it "should not be running on creation" do
+      server = Gom::Remote::HttpServer.new
+      server.running?.should == false
+    end
+  end
+
+  it "should overwrite host option" do
+    server = Gom::Remote::HttpServer.new :host => "1.2.3.4"
+    server.host.should == "1.2.3.4"
+  end
+
+  it "should overwrite port option" do
+    server = Gom::Remote::HttpServer.new :port => 9151
+    server.port.should == 9151
+  end
+
+  it "should have a base url" do
+    h, p = (Gom::Remote::HttpServer::Defaults.values_at :host, :port)
+
+    server = Gom::Remote::HttpServer.new
+    server.base_url.should == "http://#{h}:#{p}"
+    server = Gom::Remote::HttpServer.new :port => 9151
+    server.base_url.should == "http://#{h}:9151"
+    server = Gom::Remote::HttpServer.new :host => '127.0.0.1'
+    server.base_url.should == "http://127.0.0.1:#{p}"
+    server = Gom::Remote::HttpServer.new :port => 1234, :host => '10.1.1.10'
+    server.base_url.should == "http://10.1.1.10:1234"
+  end
+
+  describe "with a server" do
+    before :each do
+      @server = Gom::Remote::HttpServer.new
+    end
+
+    it "should match empty mounts to nil" do
+      @server.send(:match, (URI.parse '/foo/aa;bb;cc?p1=12&p2=oo')).should == nil
+    end
+
+    it "should not missmatch" do
+      @server.mount '^/a',     lambda { }
+      @server.mount '^/a/b',   lambda { }
+      @server.mount '^/a/b/c', lambda { }
+      @server.match(URI.parse '/x/a/b/c').should == nil
+      @server.match(URI.parse '/x/a/b').should == nil
+      @server.match(URI.parse '/x/a').should == nil
+      @server.match(URI.parse 'a').should == nil
+    end
+
+    it "should unmount" do
+      @server.mount '/a/b/c', (l = lambda { "block 6" })
+      @server.match(URI.parse '/a/b/c/d').should == l
+      @server.unmount '/a/b/c'
+      @server.match(URI.parse '/a/b/c/d').should == nil
+    end
+
+    it "should match with regexp as well" do
+      @server.mount %r{/a},     (l1 = lambda { "block 1" })
+      @server.mount %r{/a/b},   (l2 = lambda { "block 2" })
+      @server.mount %r{/a/b/c}, (l3 = lambda { "block 3" })
+      @server.match(URI.parse '/a/b').should == l2
+      @server.match(URI.parse '/a/b/c').should == l3
+      @server.match(URI.parse '/a/b/x').should == l2
+      @server.match(URI.parse '/a/b/c/d').should == l3
+    end
+
+    it "should prefer longer matches" do
+      @server.mount '/a',     (l1 = lambda { "block 1" })
+      @server.mount '/a/b',   (l2 = lambda { "block 2" })
+      @server.mount '/a/b/c', (l3 = lambda { "block 3" })
+      @server.match(URI.parse '/a/b').should == l2
+      @server.match(URI.parse '/a/b/c').should == l3
+      @server.match(URI.parse '/a/b/x').should == l2
+      @server.match(URI.parse '/a/b/c/d').should == l3
+    end
+
+    it "should match simple strings" do
+      @server.mount "/foo", (l = lambda { puts "needs some code here" })
+      @server.match(URI.parse '/foo/aa;bb;cc?p1=12&p2=oo').should == l
+    end
+
+    it "should have default mongrel options" do
+      @server.port.should == Gom::Remote::HttpServer::Defaults[:port]
+      @server.host.should == Gom::Remote::HttpServer::Defaults[:host]
+    end
+
+    #it "should dispatch a nagios callback" do
+    #  @cs.should_not_receive(:gnp_dispatcher)
+    #  response = @cs.send(:dispatch_request_uri, "/nagios;foo;bar", {}) 
+    #  response.should == [200, {"Content-Type"=>"text/plain"}, ["OK"]]
+    #end
+
+    it "should start and stop" do
+      @server.start.class.should == Thread
+      #sleep 1
+      @server.running?.should == true
+      @server.stop.should == @server
+      sleep 1
+      @server.running?.should == false
+    end
+  end
+end

data/spec/gom/remote/subscription_spec.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__)+'/../../spec_helper'
+
+describe Gom::Remote::Subscription do
+
+  describe "when created with default options" do
+    before :each do
+      @sub = (Gom::Remote::Subscription.new '/dmx/node/values')
+    end
+    it "should have a object id as name" do
+      @sub.name.should == "0x#{@sub.object_id}"
+    end
+    it "should have operations whitelist" do
+      @sub.operations.should == "update"
+    end
+    it "should have nil condition_script" do
+      @sub.condition_script.should == nil
+    end
+    it "should have a nil uri_regexp" do
+      @sub.uri_regexp.should == nil
+    end
+    it "should have a nil callback" do
+      @sub.callback.should == nil
+    end
+  end
+
+  it "should overwrite callback from options" do
+    callback  = lambda {}
+    s = (Gom::Remote::Subscription.new '/node/values', :callback => callback )
+    s.callback.should == callback
+  end
+
+  it "should overwrite name from options value" do
+    name = "test-#{Time.now.to_i}"
+    s = (Gom::Remote::Subscription.new '/node/values', :name => name)
+    s.name.should == name
+  end
+
+  describe "observer uri" do
+    it "should construct a proper gom observer uri" do
+      s = (Gom::Remote::Subscription.new '/dmx/node/values')
+      s.uri.should == "/gom/observer/dmx/node/values/.#{s.name}"
+    end
+    it "should interpret attribute paths" do
+      s = (Gom::Remote::Subscription.new '/dmx/node:attribute')
+      s.uri.should == "/gom/observer/dmx/node/attribute/.#{s.name}"
+    end
+  end
+end

data/spec/spec.opts

@@ -0,0 +1 @@
+--backtrace --debugger

data/spec/spec_helper.rb

@@ -0,0 +1,48 @@
+# figure out where we are being loaded from
+if $LOADED_FEATURES.grep(/spec\/spec_helper\.rb/).any?
+  begin
+    raise "foo"
+  rescue => e
+    puts <<-MSG
+  ===================================================
+  It looks like spec_helper.rb has been loaded
+  multiple times. Normalize the require to:
+
+    require "spec/spec_helper"
+
+  Things like File.join and File.expand_path will
+  cause it to be loaded multiple times.
+
+  Loaded this time from:
+
+    #{e.backtrace.join("\n    ")}
+  ===================================================
+    MSG
+  end
+end
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'spec'
+require 'spec/autorun'
+require 'fakeweb'
+
+require 'gom-script'
+
+Spec::Runner.configure do |config|
+  config.before :each do
+    FakeWeb.register_uri(
+      :get, "http://gom:345/gom/config/connection.txt", 
+      :body => "client_ip: 10.0.0.23"
+    )
+    FakeWeb.register_uri(
+      :get, "http://localhost:3000/gom/config/connection.txt", 
+      :body => "client_ip: 10.0.0.23"
+    )
+
+    Gom::Remote.connection = nil # reset for every test
+  end
+
+  config.after :each do
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification 
+name: gom-script
+version: !ruby/object:Gem::Version 
+  version: 0.1.2
+platform: ruby
+authors: 
+- art+com/dirk luesebrink
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2009-12-30 00:00:00 +01:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: applix
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 0.2.1
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rack
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: gom-core
+  type: :runtime
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: rspec
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: fakeweb
+  type: :development
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.7
+    version: 
+description: " \n      GOM is a schema-less object database in ruby with Resource Oriented API,\n      server-side javascript, distributed HTTP notifications and some more.\n      This gom-script script simplifies coding of clients and daemon which like\n      to listen on state change event in the GOM.\n    "
+email: dirk.luesebrink@gmail.com
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.markdown
+files: 
+- .document
+- .gitignore
+- LICENSE
+- README.markdown
+- Rakefile
+- VERSION
+- lib/gom-script.rb
+- lib/gom/remote.rb
+- lib/gom/remote/connection.rb
+- lib/gom/remote/daemon.rb
+- lib/gom/remote/entry.rb
+- lib/gom/remote/http_server.rb
+- lib/gom/remote/subscription.rb
+- spec/gom/remote/connection_spec.rb
+- spec/gom/remote/daemon_spec.rb
+- spec/gom/remote/http_server_spec.rb
+- spec/gom/remote/subscription_spec.rb
+- spec/spec.opts
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: http://github.com/crux/gom-script
+licenses: []
+
+post_install_message: 
+rdoc_options: 
+- --charset=UTF-8
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.5
+signing_key: 
+specification_version: 3
+summary: connecting scripts and daemons with a remote GOM instance
+test_files: 
+- spec/gom/remote/connection_spec.rb
+- spec/gom/remote/daemon_spec.rb
+- spec/gom/remote/http_server_spec.rb
+- spec/gom/remote/subscription_spec.rb
+- spec/spec_helper.rb