gisele-vm 0.6.0

data/lib/gisele/vm/prog_list.rb

@@ -0,0 +1,55 @@
+module Gisele
+  class VM
+    class ProgList < Component
+      extend Forwardable
+
+      def initialize(storage)
+        super()
+        @storage = storage
+      end
+
+      def self.memory
+        ProgList.new storage("memory")
+      end
+
+      def self.storage(options = nil)
+        options = {:uri => "memory"} unless options
+        options = {:uri => options } unless Hash===options
+        options[:uri] = "memory" unless options[:uri]
+        options[:uri] = "#{Sqldb.sqlite_protocol}:memory" if options[:uri]=='memory'
+        ProgList::Sqldb.new(options)
+      end
+
+      def registered(vm)
+        super
+        @storage.registered(vm)
+      end
+
+      def unregistered
+        super
+        @storage.unregistered
+      end
+
+      def connect
+        super
+        @storage.connect
+      end
+
+      def disconnect
+        super
+        @storage.disconnect
+      end
+
+      def_delegators :"@storage", :options,
+                                  :fetch,
+                                  :pick,
+                                  :save,
+                                  :clear,
+                                  :to_relation
+
+    end # class ProgList
+  end # class VM
+end # module Gisele
+require_relative 'prog_list/storage'
+require_relative 'prog_list/memory'
+require_relative 'prog_list/sqldb'

data/lib/gisele/vm/prog_list/memory.rb

@@ -0,0 +1,74 @@
+module Gisele
+  class VM
+    class ProgList
+      class Memory < Storage
+
+        def initialize(options = {})
+          super
+          @progs = []
+        end
+
+        def fetch(puid)
+          @progs[is_a_valid_puid!(puid)].dup
+        end
+
+        def pick(restriction, &bl)
+          keys = restriction.keys
+          candidate = @progs.select{|p|
+            p.to_hash(keys) == restriction
+          }.sample
+          bl.call if bl and candidate.nil?
+          candidate
+        end
+
+        def clear
+          @progs = []
+        end
+
+        def to_relation(restriction = nil)
+          progs = @progs
+          if restriction
+            keys  = restriction.keys
+            progs = progs.select{|p| p.to_hash(keys) == restriction}
+          end
+          progs = progs.map{|p| p.to_hash}
+          Alf::Relation(progs)
+        end
+
+      private
+
+        def save_prog(prog)
+          prog.puid.tap{|puid|
+            @progs[is_a_valid_puid!(puid)] = prog.dup
+          }
+        end
+
+        def register_prog(prog)
+          @progs << prog.dup.tap{|d|
+            d.puid   = @progs.size
+            d.parent = d.puid if d.parent.nil?
+            d.root   = d.puid if d.root.nil?
+          }
+          @progs.last.puid
+        end
+
+        def is_a_valid_puid!(puid)
+          case puid
+          when /^\d+$/
+            is_a_valid_puid! Integer(puid)
+          else
+            unless valid_puid?(puid)
+              raise InvalidPUIDError, "Invalid puid: `#{puid.inspect}`"
+            end
+            puid
+          end
+        end
+
+        def valid_puid?(puid)
+          (Integer===puid) and (0 <= puid) and (puid < @progs.size)
+        end
+
+      end # class Memory
+    end # class ProgList
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/prog_list/sqldb.rb

@@ -0,0 +1,123 @@
+require 'sequel'
+module Gisele
+  class VM
+    class ProgList
+      class Sqldb < Storage
+
+        attr_reader :sequel_db
+
+        def initialize(options = {})
+          super(default_options.merge(options))
+        end
+
+        def default_options
+          { :table_name => :gvm_proglist }
+        end
+
+        def self.sqlite_protocol
+          defined?(JRUBY_VERSION) ? "jdbc:sqlite" : "sqlite"
+        end
+
+        def connect
+          super
+          @sequel_db = Sequel.connect(connection_info)
+          @sequel_db.test_connection
+          ensure_schema(@sequel_db)
+          self
+        end
+
+        def disconnect
+          super
+          @sequel_db.disconnect if @sequel_db
+        end
+
+        def fetch(puid)
+          got = sequel_db[table_name].where(:puid => puid).first
+          raise InvalidPUIDError, "Invalid puid: `#{puid.inspect}`" unless got
+          decode(got)
+        end
+
+        def pick(restriction)
+          c = sequel_db[table_name].
+            where(encode(restriction)).limit(1).first
+          c && decode(c)
+        end
+
+        def clear
+          sequel_db[table_name].delete
+        end
+
+        def to_relation(restriction = nil)
+          tuples = sequel_db[table_name]
+          tuples = tuples.where(encode(restriction)) if restriction
+          tuples = tuples.map{|t| decode(t, false)}
+          Alf::Relation(tuples)
+        end
+
+      private
+
+        def save_prog(prog)
+          sequel_db[table_name].
+            where(:puid => prog.puid).
+            update(encode(prog))
+          prog.puid
+        end
+
+        def register_prog(prog)
+          tuple = encode(prog)
+          tuple.delete(:puid) if tuple[:puid].nil?
+          puid = sequel_db[table_name].insert(tuple)
+          if prog.parent.nil? or prog.root.nil?
+            sequel_db[table_name].where(:puid => puid).
+              update(:root => prog.root || puid, :parent => prog.parent || puid)
+          end
+          puid
+        end
+
+        def decode(h, as_prog = true)
+          h[:pc]       = h[:pc].to_sym               if h.has_key?(:pc)
+          h[:pc]       = -1                          if h[:pc] == :"-1"
+          h[:waitfor]  = h[:waitfor].to_sym          if h.has_key?(:waitfor)
+          h[:waitlist] = ::Kernel.eval(h[:waitlist]) if h.has_key?(:waitlist)
+          h[:input]    = ::Kernel.eval(h[:input])    if h.has_key?(:input)
+          as_prog ? Prog.new(h) : h
+        end
+
+        def encode(prog)
+          h = prog.to_hash
+          h[:pc]       = h[:pc].to_s                 if h.has_key?(:pc)
+          h[:waitfor]  = h[:waitfor].to_s            if h.has_key?(:waitfor)
+          h[:waitlist] = h[:waitlist].inspect        if h.has_key?(:waitlist)
+          h[:input]    = h[:input].inspect           if h.has_key?(:input)
+          h
+        end
+
+      private
+
+        def connection_info
+          @options[:connection_info] || @options[:uri]
+        end
+
+        def table_name
+          @options[:table_name]
+        end
+
+        def ensure_schema(db)
+          return if db.table_exists?(tn = table_name)
+          db.create_table(tn) do
+            primary_key :puid
+            Integer     :parent
+            Integer     :root
+            String      :pc
+            String      :waitfor
+            String      :waitlist
+            String      :input
+            index       :root
+            index       :waitfor
+          end
+        end
+
+      end # class Sqldb
+    end # class ProgList
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/prog_list/storage.rb

@@ -0,0 +1,31 @@
+module Gisele
+  class VM
+    class ProgList
+      class Storage < Component
+        attr_reader :options
+
+        def initialize(options = {})
+          super()
+          @options = options
+        end
+
+        def save(prog)
+          if Array===prog
+            prog.map{|p| save(p)}
+          else
+            prog = is_a_prog!(prog)
+            prog.puid ? save_prog(prog) : register_prog(prog)
+          end
+        end
+
+      private
+
+        def is_a_prog!(prog)
+          raise ArgumentError, "Invalid prog: #{prog}", caller unless Prog===prog
+          prog
+        end
+
+      end # class Storage
+    end # class ProgList
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/proxy.rb

@@ -0,0 +1,14 @@
+module Gisele
+  class VM
+    module Proxy
+
+      def default_options
+        { :uri => "druby://localhost:6789" }
+      end
+      module_function :default_options
+
+    end # module Proxy
+  end # class VM
+end # module Gisele
+require_relative 'proxy/server'
+require_relative 'proxy/client'

data/lib/gisele/vm/proxy/client.rb

@@ -0,0 +1,64 @@
+require 'drb'
+module Gisele
+  class VM
+    module Proxy
+      class Client
+        extend  Forwardable
+
+        attr_reader   :options
+        attr_accessor :logger
+        attr_reader   :registry
+
+        def initialize(options = {})
+          init_lifecycle
+          @options  = Proxy.default_options.merge(options)
+          @registry = Registry.new(self)
+          yield(self) if block_given?
+          @logger ||= Logger.new($stdout, Logger::DEBUG)
+        end
+
+        include Robustness
+        include Logging
+        include Lifecycle
+
+        def run
+          DRb.start_service
+          @vm = DRbObject.new nil, options[:uri]
+          @vm.to_s
+          yield(@vm) if block_given?
+          super
+        end
+
+        def stop
+          DRb.stop_service
+          super
+        end
+
+        def_delegators :registry,      :components,
+                                       :register,
+                                       :unregister,
+                                       :connect,
+                                       :disconnect,
+                                       :connected?
+        def_delegators :"@vm",         :proglist,
+                                       :event_manager
+        def_delegators :"@vm",         :start,
+                                       :resume,
+                                       :progress
+        def_delegators :"@vm",         :pick,
+                                       :fetch,
+                                       :save,
+                                       :progs
+        def_delegators :"@vm",         :event,
+                                       :subscribe,
+                                       :unsubscribe
+
+      end # Client
+    end # module Proxy
+
+    def self.drb_client(&bl)
+      Proxy::Client.new.run(&bl)
+    end
+
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/proxy/server.rb

@@ -0,0 +1,29 @@
+require 'drb'
+module Gisele
+  class VM
+    module Proxy
+      class Server < Component
+
+        attr_reader :options
+
+        def initialize(options = {})
+          super()
+          @options = Proxy.default_options.merge(options)
+        end
+
+        def connect
+          super
+          DRb.start_service options[:uri], vm
+          info "VM proxy started at #{DRb.uri}."
+        end
+
+        def disconnect
+          DRb.stop_service
+          DRb.thread.join if DRb.thread
+          super
+        end
+
+      end # Server
+    end # module Proxy
+  end # class VM
+end # module Gisele

data/lib/gisele/vm/registry.rb

@@ -0,0 +1,57 @@
+module Gisele
+  class VM
+    class Registry < Component
+
+      attr_reader :components
+
+      def initialize(vm)
+        super()
+        @vm         = vm
+        @components = []
+        @cconnected = []
+      end
+
+      def register(component, prior = false)
+        raise NotImplementedError,
+              "Hot registration is not implemented." if connected?
+        if prior
+          @components.unshift component
+        else
+          @components.push component
+        end
+        component.registered(vm)
+      end
+
+      def unregister(component)
+        raise NotImplementedError,
+              "Hot unregistration is not implemented." if connected?
+        @components.delete(component)
+        component.unregistered
+      end
+
+      def connect
+        super
+        @components.each do |c|
+          c.connect
+          @cconnected << c
+        end
+      rescue Exception => ex
+        fatal error_message(ex, "Unable to connect VM:")
+        disconnect
+        raise
+      end
+
+      def disconnect
+        super
+        @cconnected.each do |c|
+          begin
+            c.disconnect
+          rescue Exception => ex
+            warn("Error when disconnecting #{c}: #{ex.message}") rescue nil
+          end
+        end
+      end
+
+    end # class Registry
+  end # class VM
+end # module Gisele