seapig-server 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 33a42ea75372a1f1cf7fa95c5f7ca88ad46d789c
+  data.tar.gz: daf21ca47cc732516621bb5b05fa6a453655203a
+SHA512:
+  metadata.gz: 68d63fc5779b3f3c3e19df5d403c7227ec8a4e233a82a23189db8bec15ce2fde2796706abaf913f45de8435116597cdc06b416d245972f634f781bceaf6cc8f8
+  data.tar.gz: 9dc56616fb19d88bbab9ce34f22faf22494b1700faf1679eef3f45a1bc24c506fead2a4dbcc355b69b23bc056ba86f8672cd99bfd5b763b731d45c286ec5e045

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2015 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/README.rdoc

@@ -0,0 +1,36 @@
+= Seapig
+
+Nothing here yet.
+
+To cover:
+
+* what are seapigs and why they exist? (why not just having a db table?)
+  * link to https://www.youtube.com/watch?v=_y4DbZivHCY
+* properties of seapig system
+  * data is cached in memory
+  * only diffs are sent
+  * data is generated in separate processes
+  * data gets regenerated on dependency change (immediately on db change)
+* describe current limits
+  * one level deps only
+  * single object can have at most one generation process running at all times
+  * cache is dropped when last client unlinks
+  * no client-side timeout detection
+  * postgres only (but is that really a problem? ;))
+* graph of server/client side seapig object states
+* disclaimer on non-efficient code. it's all a draft, a test of idea.
+* rails not needed
+* stuff will change
+* seapig = firebase for apps that need real db
+* works nicely with mithril
+* how to use this shit
+  * dummy app is a minimal demo
+  * bundle exec rails s
+  * bundle exec ruby ../../bin/seapig-server.rb
+  * bundle exec ruby ../../bin/seapig-worker.rb ws://127.0.0.1:3001/seapig
+  * bundle exec ruby ../../bin/seapig-notifier.rb ws://127.0.0.1:3001/seapig
+  * application.js needs: require seapig/seapig
+  * application.js needs: require json-patch
+  * ActiveRecord models that are used for triggering regeneration of data need:
+    * acts_as_seapig_dependency
+    * and seapig_dependency_changed after commits

data/Rakefile

@@ -0,0 +1,37 @@
+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
+
+#APP_RAKEFILE = File.expand_path("../test/dummy/Rakefile", __FILE__)
+#load 'rails/tasks/engine.rake'
+
+
+#load 'rails/tasks/statistics.rake'
+
+
+
+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-server

@@ -0,0 +1,289 @@
+#!/bin/env ruby
+
+require 'websocket-eventmachine-server'
+require 'json'
+require 'jsondiff'
+require 'hana'
+require 'set'
+
+
+class String
+
+	def starexp
+		Regexp.new(Regexp.escape(self).gsub('\*','.*?'))
+	end
+
+
+	def starexp?
+		self.include?('*')
+	end
+
+end
+
+
+
+class SeapigObject
+
+	attr_reader :id, :version, :valid
+
+	@@objects_by_id = Hash.new { |hash,object_id|
+		puts "Creating: "+(object = SeapigObject.new(object_id)).id
+		hash[object_id] = object
+	}
+
+
+	def self.[](id)
+		@@objects_by_id[id]
+	end
+
+
+	def self.all
+		@@objects_by_id.values
+	end
+
+
+	def self.matching(id)
+		@@objects_by_id.values.select { |object| object.matches?(id) }
+	end
+
+
+	def matches?(id)
+		@id =~ id.starexp
+	end
+
+	
+	def initialize(id)
+		@id = id
+		@valid = false
+		@object = {}
+		@version = 0
+		@@objects_by_id[@id] = self
+	end
+
+	
+	def self.gc
+		used_object_ids = Set.new
+		Client.all.each { |client| used_object_ids.merge(client.consumes.map { |object| object.id }) } #objects with direct consuments (no pattern matching)
+		@@objects_by_id.values.each { |object| used_object_ids << object.id if Client.all.find { |client| client.produces.include?(object.id) } and Client.all.find { |client| client.consumes.find { |consumed| consumed.id.starexp? and object.id =~ consumed.id.starexp } } } #objects having producers AND wildcard consuments
+		@@objects_by_id.values.each { |object| object.version.keys.each { |key| used_object_ids << key } if object.version.kind_of?(Hash) } # objects that others depend on
+		@@objects_by_id.keys.select { |id| not used_object_ids.include?(id) }.each { |id|
+			Client.all.select { |client| client.consumes.find { |object| object.id.starexp? and id =~ object.id.starexp } }.each { |client|
+				puts "Destroying: "+id
+				client.socket.send JSON.dump(action: 'object-destroy', id: id)
+			}
+			puts "Deleting: "+id
+			@@objects_by_id.delete(id) 
+		}
+	end
+
+
+	def patch(patch, value, from_version, new_version)
+		print "Patching version:"+@version.inspect+" from_version:"+from_version.inspect+" new_version:"+new_version.inspect+' --> '  
+		if from_version == @version or from_version == 0
+			puts 'Clean'
+			old_object = JSON.load(JSON.dump(@object))
+			old_version = @version
+			@object.clear if from_version == 0 or value
+			Hana::Patch.new(patch).apply(@object) if patch
+			@object.merge!(value) if value
+			@version = new_version
+			Client.all.each { |client| send(client, old_version, old_object) }
+			SeapigObject.all.each { |object| object.check_validity }
+		elsif from_version > @version
+			puts "Lost some updates, reinitializing object"
+			@version = 0
+			@object.clear
+			@valid = false
+		else
+			puts "Late update, ignoring"
+		end
+	end
+
+
+	def send(client, old_version, old_object, patch = nil)
+		return false if not client.consumes.find { |object| (object == self) or self.matches?(object.id) }
+		puts 'Sending '+self.id
+		client.socket.send JSON.dump(
+					   action: 'object-update',
+					   id: @id,
+					   old_version: old_version,
+					   new_version: @version,
+					   patch: (patch or JsonDiff.generate(old_object, @object))) 
+	end
+
+	
+	def check_validity
+		@valid = if not @version.kind_of?(Hash) then (@version > 0) else not @version.to_a.find { |dependency_id, dependency_version|
+						SeapigObject[dependency_id] and SeapigObject[dependency_id].version and SeapigObject[dependency_id].version > dependency_version
+					} end
+	end
+
+
+	def inspect
+		'<SO:%s:%s:%s>'%[@id, @version, (@valid and 'V' or 'I')]
+	end
+	
+end
+
+
+
+class Client
+
+	attr_reader :produces, :consumes, :socket, :producing, :index
+	attr_accessor :options
+
+	@@clients_by_socket = {}
+	@@count = 0
+
+	
+	def self.[](id)
+		@@clients_by_socket[id]
+	end
+
+
+	def self.all
+		@@clients_by_socket.values
+	end
+
+
+	def initialize(socket)
+		@index = @@count += 1
+		puts 'Creating client: '+@index.to_s
+		@socket = socket
+		@options = {}
+		@produces = []
+		@consumes = []
+		@producing = nil
+		@@clients_by_socket[socket] = self
+	end
+	
+
+	def id
+		(@options['name'] or "") + ':' + @index.to_s
+	end
+
+
+	def destroy
+		puts 'Destroying client: '+@index.to_s
+		@@clients_by_socket.delete(@socket)
+		SeapigObject.gc
+		Client.all.find { |client| client.assign(@producing) } if @producing and SeapigObject.all.include?(@producing)
+	end
+
+
+	def producer_register(pattern)
+		@produces.push(pattern)
+		SeapigObject.all.each { |object| self.assign(object) }
+	end
+
+
+	def consumer_register(object)
+		@consumes.push(object)
+		Client.all.each { |client| client.produces.each { |pattern| SeapigObject[pattern] if (not pattern.starexp?) and (pattern =~ object.id.starexp) } } if object.id.starexp?
+		SeapigObject.matching(object.id).each { |object|
+			Client.all.find { |client| client.assign(object) }
+			object.send(self,nil,{}) if object.valid
+		}
+	end
+
+
+	def assign(object)
+		puts 'Assign? %20s <> %-30s - %s'%[self.id, object.id, [object.valid,object.id.starexp?,@producing,Client.all.find { |client| client.producing == object },(not @produces.find { |pattern| object.id =~ pattern.starexp })].map { |b| b and 'T' or 'F' }.join('')]
+		return true if object.valid
+		return true if object.id.starexp?
+		return false if @producing
+		return true if Client.all.find { |client| client.producing == object }
+		return false if not @produces.find { |pattern| object.id =~ pattern.starexp }
+		puts 'Assigning: '+object.id+'    to: '+self.id
+		@socket.send JSON.dump(action: 'object-produce', id: object.id)
+		@producing = object
+	end
+
+
+	def release(object)
+		puts 'Releasing: '+object.id+'    from: '+self.id
+		@producing = nil if @producing == object
+	end
+
+	
+	def ping
+		@socket.ping
+	end
+
+	
+	def pong
+		@pong_time = Time.new
+	end
+
+	
+	def check_ping_timeout
+		@socket.close if Time.new - pong > 60
+	end
+end
+
+
+
+
+
+EM.run {
+
+
+	WebSocket::EventMachine::Server.start(host: "0.0.0.0", port: 3001) { |client_socket|
+		
+		client_socket.onmessage { |message|
+			client = Client[client_socket]
+			message = JSON.load message
+			puts "-"*80 + ' ' + Time.new.to_s + "\nMessage: %-20s    %-30s    %s:%s"%[client.id, message['action'], (message["id"] and "ID" or "Pattern"),(message["id"] or message["pattern"])]
+			object = SeapigObject[message['id']] if message['id']
+			case message['action']
+			when 'object-producer-register'
+				fail unless message['pattern']
+				client.producer_register(message['pattern'])
+			when 'object-producer-unregister'
+				fail unless message['pattern']
+				client.producer_unregister(message['pattern'])
+			when 'object-patch'
+				fail unless message['id'] and message['new_version'] and message['old_version']
+				SeapigObject.gc
+				if SeapigObject.all.include?(object) # ignoring objects nobody listens to
+					object.patch(message['patch'], message['value'], message['old_version'], message['new_version'])
+					client.release(object)
+					SeapigObject.all.each { |object| Client.all.find { |client| client.assign(object) } }
+				end
+			when 'object-consumer-register'
+				fail unless message['id']
+				client.consumer_register(object)
+			when 'object-consumer-unregister'
+				fail unless message['id']
+				client.consumer_unregister(object)
+			when 'client-options-set'
+				fail unless message['options']
+				client.options = message['options']
+			else
+				puts '***** WTF, got message with action: ' + message['action'].inspect
+			end
+			puts "Clients:\n"+Client.all.map { |client| "\t%-20s    produces:%s    consumes:%s"%[client.id,client.produces.inspect,client.consumes.map { |obj| obj.id }] }.join("\n")+"\n"
+			puts "Objects:\n"+SeapigObject.all.map { |object| "\t%s"%[object.inspect] }.join("\n")+"\n"
+		}
+
+		
+		client_socket.onopen { Client.new(client_socket) }
+		client_socket.onclose { Client[client_socket].destroy if Client[client_socket] }
+		client_socket.onpong { Client[client_socket].pong }
+	}
+
+	
+	EM.add_periodic_timer(10) {
+		Client.all.each { |client|
+			client.ping
+		}
+	}
+
+
+	EM.add_periodic_timer(10) {
+		Client.all.each { |client|
+			client.check_ping_timeout 
+		}
+	}
+	
+}

data/lib/seapig-server.rb

@@ -0,0 +1,4 @@
+#require "seapig/server.rb"
+
+module Seapig
+end

data/lib/seapig/version.rb

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

data/test/dummy/README.rdoc

@@ -0,0 +1,28 @@
+== README
+
+This README would normally document whatever steps are necessary to get the
+application up and running.
+
+Things you may want to cover:
+
+* Ruby version
+
+* System dependencies
+
+* Configuration
+
+* Database creation
+
+* Database initialization
+
+* How to run the test suite
+
+* Services (job queues, cache servers, search engines, etc.)
+
+* Deployment instructions
+
+* ...
+
+
+Please feel free to use a different markup language if you do not plan to run
+<tt>rake doc:app</tt>.

data/test/dummy/Rakefile

@@ -0,0 +1,6 @@
+# Add your own tasks in files placed in lib/tasks ending in .rake,
+# for example lib/tasks/capistrano.rake, and they will automatically be available to Rake.
+
+require File.expand_path('../config/application', __FILE__)
+
+Rails.application.load_tasks

data/test/dummy/app/assets/javascripts/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require_tree .
+//= require seapig/seapig
+//= require json-patch