seapig-client-ruby 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a2ff3c8fd5b96df4a2642b77584d2ac0f6da66ad
+  data.tar.gz: 8e9571f50d92b5805304bdaa49606b6906060aac
+SHA512:
+  metadata.gz: 8c93cf68cf379b969aa0756b5de9265001ef48a15c141fbdae85e0b0d8d419b61ae73d1dcb1ed5625594d70f5d804ac34f06fc1b9e724290efb02056e99b079a
+  data.tar.gz: e391af96eeb2170b8b9c58a8a3fd17f296dc00af4f3f58c9be54493dc5d35025afd063d3815bb57942d0f6814611c26fed3f85fab0e491551384d66ab9355f80

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015-2017 yunta
+
+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/Rakefile

@@ -0,0 +1,31 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Seapig'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.rdoc')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+
+
+Bundler::GemHelper.install_tasks
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'lib'
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+
+task default: :test

data/bin/seapig-observer

@@ -0,0 +1,27 @@
+#!/bin/env ruby
+
+require 'seapig-client'
+require 'slop'
+require 'pp'
+
+
+OPTIONS = Slop.parse { |o|
+	o.string '-c', '--connect', "Seapig server address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001"
+	o.on '-h', '--help' do puts o; exit end
+}
+
+EM.run {
+
+	SeapigClient.new(OPTIONS["connect"],name: 'observer').slave(OPTIONS.arguments[0]).onchange { |what|
+		puts "-"*80 + " " + Time.new.to_s
+		puts what.id
+		if what.destroyed
+			puts "DESTROYED"
+		else
+			puts what.version
+			pp what
+		end
+		puts
+	}
+
+}

data/bin/seapig-worker

@@ -0,0 +1,51 @@
+#!/bin/env ruby
+
+require 'seapig-client'
+require 'slop'
+
+STDOUT.sync = true
+
+
+OPTIONS = Slop.parse { |o|
+	o.string '-c', '--connect', "Seapig server address (default: ws://127.0.0.1:3001)", default: "ws://127.0.0.1:3001"
+	o.on '-h', '--help' do puts o; exit end
+}
+
+
+class Producer
+
+	class << self
+		attr_reader :patterns
+	end
+
+	def self.all
+		@producers ||= ObjectSpace.each_object(Class).select { |klass| klass < Producer }
+	end
+
+end
+
+($LOAD_PATH+['./lib']).each { |load_path|
+	Dir[load_path+'/seapigs/*.rb'].each { |f| require f }
+}
+
+
+
+
+EM.run {
+
+	client = SeapigClient.new(OPTIONS["connect"], name: 'worker')
+
+	Producer.all.each { |producer|
+		producer.patterns.each { |pattern|
+			object = client.master(pattern)
+			object.onproduce { |child|
+				start = Time.new
+				print 'Sent  %-30s  '%[child.id]
+				data, version = producer.produce(child.id)
+				child.set(object: data, version: version)
+				puts 'in %5.2fs - %s'%[(Time.new-start).to_f,version.inspect]
+			}
+		}
+	}
+
+}

data/lib/seapig-client-ruby/client.rb

@@ -0,0 +1,425 @@
+require 'websocket-eventmachine-client'
+require 'json'
+require 'jsondiff'
+require 'hana'
+require 'narray'
+
+
+module WebSocket
+	module Frame
+		class Data < String
+			def getbytes(start_index, count)
+				data = self[start_index, count]
+				if @masking_key
+					payload_na = NArray.to_na(data,"byte")
+					mask_na = NArray.to_na((@masking_key.pack("C*")*((data.size/4) + 1))[0...data.size],"byte")
+					data = (mask_na ^ payload_na).to_s
+				end
+				data
+			end
+		end
+	end
+end
+
+
+
+class SeapigClient
+
+	attr_reader :uri, :socket, :connected, :error
+
+	def initialize(uri, options={})
+		@uri = uri
+		@options = options
+		@slave_objects = {}
+		@master_objects = {}
+		@connected = false
+		@socket = nil
+		@error = nil
+		connect
+	end
+
+
+	def connect
+
+		disconnect if @socket
+		@reconnect_on_close = true
+
+		@timeout_timer ||= EM.add_periodic_timer(10) {
+			next if not @socket
+			next if Time.new.to_f - @last_communication_at < 20
+			puts "Seapig ping timeout, reconnecting" if @options[:debug]
+			connect
+		}
+
+		@last_communication_at = Time.new.to_f
+
+		puts 'Connecting to seapig server' if @options[:debug]
+		@socket = WebSocket::EventMachine::Client.connect(uri: @uri)
+
+		@socket.onopen {
+			puts 'Connected to seapig server' if @options[:debug]
+			@connected = true
+			@error = nil
+			@onstatuschange_proc.call(self) if @onstatuschange_proc
+			@socket.send JSON.dump(action: 'client-options-set', options: @options)
+			@slave_objects.each_pair { |id, object|
+				@socket.send JSON.dump(action: 'object-consumer-register', pattern: id, :"version-known" => object.version)
+				object.validate
+			}
+			@master_objects.each_pair { |id, object|
+				@socket.send JSON.dump(action: 'object-producer-register', pattern: id, :"version-known" => object.version)
+			}
+			@last_communication_at = Time.new.to_f
+		}
+
+		@socket.onclose(&(@socket_onclose = Proc.new { |code, reason|
+			puts 'Seapig connection closed (code:'+code.inspect+', reason:'+reason.inspect+')' if @options[:debug]
+			@connected = false
+			@socket = nil
+			@timeout_timer.cancel if @timeout_timer
+			@timeout_timer = nil
+			@slave_objects.values.each { |object| object.invalidate }
+			@onstatuschange_proc.call(self) if @onstatuschange_proc
+			EM.cancel_timer(@reconnection_timer) if @reconnection_timer
+			@reconnection_timer = nil
+			@reconnection_timer = EM.add_timer(1) { connect } if @reconnect_on_close
+		}))
+
+		@socket.onerror { |error|
+			puts 'Seapig socket error: '+error.inspect if @options[:debug]
+			@error = { while: @socket ? "connecting" : "connected", error: error }
+			@socket_onclose.call(nil, error) if @socket
+		}
+
+		@socket.onmessage { |data|
+			message = JSON.load(data)
+			case message['action']
+			when 'object-update'
+				@slave_objects.each_pair { |id, object|
+					object.patch(message) if object.matches(message['id'])
+				}
+			when 'object-destroy'
+				@slave_objects.each_pair { |id, object|
+					object.destroy(message) if object.matches(message['id'])
+				}
+				@master_objects.each_pair { |id, object|
+					object.destroy(message) if object.matches(message['id'])
+				}
+			when 'object-produce'
+				handler = @master_objects.values.find { |object| object.matches(message['id']) }
+				puts 'Seapig server submitted invalid "produce" request: '+message.inspect if (not handler) and @options[:debug]
+				handler.produce(message['id'],message['version-inferred']) if handler
+			else
+				raise 'Seapig server submitted an unsupported message: '+message.inspect
+			end
+			@last_communication_at = Time.new.to_f
+		}
+
+		@socket.onping {
+			@last_communication_at = Time.new.to_f
+		}
+
+	end
+
+
+	def disconnect(detach_fd = false)
+		@reconnect_on_close = false
+		if @timeout_timer
+			@timeout_timer.cancel
+			@timeout_timer = nil
+		end
+		if @reconnection_timer
+			EM.cancel_timer(@reconnection_timer)
+			@reconnection_timer = nil
+		end
+		if @socket
+			if detach_fd
+				IO.new(@socket.detach).close
+				@socket.onclose {}
+				@socket_onclose.call("fd detach", "fd detach")
+			else
+				@socket.onclose {}
+				@socket.close
+				@socket_onclose.call("close","close")
+			end
+		end
+	end
+
+
+	def detach_fd
+		disconnect(true)
+	end
+
+
+	def onstatuschange(&block)
+		@onstatuschange_proc = block
+		self
+	end
+
+
+	def slave(id, options={})
+		raise "Both or none of 'object' and 'version' are needed" if (options[:object] and not options[:version]) or (not options[:object] and options[:version])
+		@slave_objects[id] = if id.include?('*') then SeapigWildcardSlaveObject.new(self, id, options) else SeapigSlaveObject.new(self, id, options) end
+		@socket.send JSON.dump(action: 'object-consumer-register', pattern: id, :"version-known" => @slave_objects[id].version) if @connected
+		@slave_objects[id]
+	end
+
+
+	def master(id, options={})
+		@master_objects[id] = if id.include?('*') then SeapigWildcardMasterObject.new(self, id, options) else SeapigMasterObject.new(self, id, options) end
+		@socket.send JSON.dump(action: 'object-producer-register', pattern: id, :"version-known" => @master_objects[id].version) if @connected
+		@master_objects[id]
+	end
+
+
+	def unlink(id)
+		if @slave_objects[id]
+			@slave_objects.delete(id)
+			@socket.send(JSON.stringify(action: 'object-consumer-unregister', pattern: id)) if @connected
+		end
+		if @master_objects[id]
+			@master_objects.delete(id)
+			@socket.send(JSON.stringify(action: 'object-producer-unregister', pattern: id)) if @connected
+		end
+	end
+
+end
+
+
+
+class SeapigObject < Hash
+
+	attr_reader :id, :version, :initialized, :destroyed
+
+
+	def initialize(client, id, options)
+		@client = client
+		@id = id
+		@destroyed = false
+		@ondestroy_proc = nil
+		@onstatuschange_proc = nil
+		@initialized = !!options[:object]
+		self.merge!(options[:object]) if options[:object].kind_of?(Hash)
+	end
+
+
+	def destroy(id)
+		@destroyed = true
+		@onstatuschange_proc.call(self) if @onstatuschange_proc
+		@ondestroy_proc.call(self) if @ondestroy_proc
+	end
+
+
+	def matches(id)
+		id =~ Regexp.new(Regexp.escape(@id).gsub('\*','.*?'))
+	end
+
+
+	def sanitized
+		JSON.load(JSON.dump(self))
+	end
+
+
+	def ondestroy(&block)
+		@ondestroy_proc = block
+		self
+	end
+
+
+	def onstatuschange(&block)
+		@onstatuschange_proc = block
+		self
+	end
+
+
+	def unlink
+		@client.unlink(@id)
+	end
+
+end
+
+
+
+class SeapigSlaveObject < SeapigObject
+
+	attr_reader :received_at, :valid
+
+
+	def initialize(client, id, options)
+		super(client, id, options)
+		@version = (options[:version] or 0)
+		@valid = false
+		@received_at = nil
+	end
+
+
+	def onchange(&block)
+		@onchange_proc = block
+		self
+	end
+
+# ----- for SeapigClient
+
+	def patch(message)
+		@received_at = Time.new
+		old_self = JSON.dump(self)
+		if (not message['version-old']) or (message['version-old'] == 0) or message.has_key?('value')
+			self.clear
+		elsif not @version == message['version-old']
+			raise "Seapig lost some updates, this should never happen: "+[self, @version, message].inspect
+		end
+		if message['value']
+			self.merge!(message['value'])
+		else
+			Hana::Patch.new(message['patch']).apply(self)
+		end
+		@version = message['version-new']
+		@valid = true
+		@initialized = true
+		@onstatuschange_proc.call(self) if @onstatuschange_proc
+		@onchange_proc.call(self) if @onchange_proc and old_self != JSON.dump(self)
+	end
+
+
+	def validate
+		@valid = @initialized
+		@onstatuschange_proc.call(self) if @onstatuschange_proc
+	end
+
+
+	def invalidate
+		@valid = false
+		@onstatuschange_proc.call(self) if @onstatuschange_proc
+	end
+
+
+end
+
+
+class SeapigMasterObject < SeapigObject
+
+	attr_accessor :stall
+
+
+	def initialize(client, id, options)
+		super(client, id, options)
+		@version = (options[:version] or [(Time.new.to_f*1000).floor, 0])
+		@shadow = self.sanitized
+		@stall = false
+	end
+
+
+	def onproduce(&block)
+		@onproduce_proc = block
+		self
+	end
+
+
+	def set(options={})
+		@version = options[:version] if options[:version]
+		if options[:object]
+			@stall = false
+			self.clear
+			self.merge!(options[:object])
+		elsif options[:object] == false or options[:stall]
+			@stall = true
+		end
+		@shadow = sanitized
+		@initialized = true
+		upload(0, {}, @version, @stall ? false : @shadow)
+	end
+
+
+	def bump(options={})
+		version_old = @version
+		data_old = @shadow
+		@version = (options[:version] or [version_old[0], version_old[1]+1])
+		@shadow = sanitized
+		@initialized = true
+		upload(version_old, data_old, @version, @stall ? false : @shadow)
+	end
+
+# ----- for SeapigClient
+
+ 	def produce(id, version_inferred)
+		if @onproduce_proc
+			@onproduce_proc.call(self, version_inferred)
+		else
+			raise "Master object #{id} has to either be initialized at all times or have an onproduce callback" if not @initialized
+			upload(0, {}, @version, @shadow)
+		end
+	end
+
+private
+
+	def upload(version_old, data_old, version_new, data_new)
+		if @client.connected
+			if version_old == 0 or data_new == false
+				@client.socket.send JSON.dump(id: @id, action: 'object-patch', :"version-new" => version_new, value: data_new)
+			else
+				diff = JsonDiff.generate(data_old, data_new)
+				if JSON.dump(diff).size < JSON.dump(data_new).size #can we afford this?
+					@client.socket.send JSON.dump(id: @id, action: 'object-patch', :'version-old' => version_old, :'version-new' => version_new, patch: diff)
+				else
+					@client.socket.send JSON.dump(id: @id, action: 'object-patch', :'version-new' => version_new, value: data_new)
+				end
+			end
+		end
+		self
+	end
+
+end
+
+
+
+
+class SeapigWildcardSlaveObject < SeapigSlaveObject
+
+
+	def patch(message)
+		self[message['id']] ||= SeapigSlaveObject.new(@client, message['id'],{}).onchange(&@onchange_proc)
+		self[message['id']].patch(message)
+	end
+
+
+	def destroy(id)
+		return if not destroyed = self.delete(id)
+		destroyed.destroy(id)
+	end
+
+end
+
+
+
+class SeapigWildcardMasterObject < SeapigMasterObject
+
+	def initialize(client, id, options)
+		super(client, id, options)
+		@children = ObjectSpace::WeakMap.new
+		@options = options
+	end
+
+
+	def [](id)
+		key = @children.keys.find { |key| key == id }
+		@children[(key or id)] ||= SeapigMasterObject.new(@client, id, @options)
+	end
+
+
+	def produce(id, version_inferred)
+		child = self[id]
+		if @onproduce_proc
+			@onproduce_proc.call(child, version_inferred)
+		else
+			child.send
+		end
+	end
+
+
+	def destroy(message)
+		key = @children.keys.find { |key| key == id }
+		return if not (key and destroyed = @children[key])
+		destroyed.destroy(id)
+	end
+
+end

data/lib/seapig-client-ruby/version.rb

@@ -0,0 +1,3 @@
+module Seapig
+	VERSION = "0.2.0"
+end

data/lib/seapig-client.rb

@@ -0,0 +1,4 @@
+require "seapig-client-ruby/client.rb"
+
+module SeapigClientRuby
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: seapig-client-ruby
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- yunta
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-02-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-eventmachine-client
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: jsondiff
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: hana
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: slop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: meh
+email:
+- maciej.blomberg@mikoton.com
+executables:
+- seapig-observer
+- seapig-worker
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- Rakefile
+- bin/seapig-observer
+- bin/seapig-worker
+- lib/seapig-client-ruby/client.rb
+- lib/seapig-client-ruby/version.rb
+- lib/seapig-client.rb
+homepage: https://github.com/yunta-mb/seapig-client-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.2
+signing_key: 
+specification_version: 4
+summary: Transient object synchronization lib - client
+test_files: []