seamless 1.0.0

data/bin/seamless

@@ -0,0 +1,36 @@
+#!/usr/bin/env ruby
+
+freeze   = ARGV.any? { |option| %w(--freeze -f).include?(option) }
+app_path = ARGV.first
+
+require 'rubygems'
+gem 'rails', '>= 1.2.3'
+
+# find the path to RAILS
+rails_gem = Gem.cache.search('rails').last
+RAILS = rails_gem.full_gem_path
+
+require RAILS + '/lib/ruby_version_check'
+Signal.trap("INT") { puts; exit }
+
+require RAILS + '/lib/rails/version'
+if %w(--version -v).include? ARGV.first
+  puts "Rails #{Rails::VERSION::STRING}"
+  exit(0)
+end
+
+
+require RAILS + '/lib/rails_generator'
+require 'rails_generator/scripts/generate'
+
+Rails::Generator::Base.use_application_sources!
+
+path = File.dirname(__FILE__) + '/../'
+
+Rails::Generator::Base.sources << Rails::Generator::PathSource.new('', path)
+
+# execute the seamless generator
+Rails::Generator::Scripts::Generate.new.run(ARGV, {:generator => 'seamless', :source => path + 'seamless', :source_root => path + 'seamless', 'railspath'=>'../../rails-'+rails_gem.version.to_s})
+
+Dir.chdir(app_path) { `rake rails:freeze:gems`; puts "froze" } if freeze
+

data/lib/seamless.rb

@@ -0,0 +1,70 @@
+require 'json'
+require 'action_controller'
+require 'active_record'
+require 'md5'
+
+unless defined?(SEAMLESS_VERSION)
+
+	SEAMLESS_VERSION = '1.0.RC4.127'
+	SEAMLESS_SERVICES = Array.new
+ 
+    def model_name(name)
+      name.to_s.gsub(/[::]{2}/,'.').split('.').collect {|token| token.underscore }.join('.')
+    end
+  
+  	def silence_warnings
+    	old_verbose, $VERBOSE = $VERBOSE, nil
+    	yield
+  	ensure
+    	$VERBOSE = old_verbose
+  	end	
+
+    #
+    # OK, I realize this might be a little bad, but we include a few dependencies 
+    # which print out stupid warnings on boot - we're going to suppress that
+    #
+    silence_warnings do 
+	    #
+  		# require dependencies
+  		#
+		  Dir[File.dirname(__FILE__)+'/seamless/*.rb'].sort.each do |file|
+			  require file[0..-4]
+		  end
+	  end
+	  
+    #
+    # trick to allow changing ActiveRecord logging stream
+    #
+    def log_to(stream)
+      ActiveRecord::Base.logger = Logger.new(stream)
+      ActiveRecord::Base.clear_active_connections!
+    end
+
+    #
+    # shortcut to turn on logging to stdout
+    #
+    def log_to_stdout
+       log_to STDOUT
+    end	
+    
+  	#
+  	# load any services
+  	#
+  	Dir[RAILS_ROOT + '/app/services/*_service.rb'].each do |file|
+  		require file[0..-4]
+  		name = Inflector.camelize(File.basename(file).chomp('_service.rb')) 
+  		klass = eval(name + 'Service')
+  		mh = klass.instance
+  	end
+  	
+    #
+    # register a message broker listener for admin seamless models
+    #
+    sam_proc = Proc.new do |req,type,obj|
+   	    resp = {'success'=>true, 'models'=> SEAMLESS_SERVICES}
+    	Seamless::Dispatcher.instance.outgoing(req,'seamless.admin.models.response',resp)
+    end
+    Seamless::MessageBroker.register_listener('seamless.admin.models.request',sam_proc)
+
+  	puts "=> Seam(less) on Rails #{SEAMLESS_VERSION}"
+end

data/lib/seamless/active_record_extension.rb

@@ -0,0 +1,11 @@
+class ActiveRecord::Base
+    # Converts the ActiveRecord object to a JSON string. Only columns with simple
+    # types are included in this object so no recursion problems can occur.
+    def to_json(*a)
+      result = Hash.new  
+      self.class.columns.each do |column|
+        result[column.name.to_sym] = self.send(column.name)
+      end
+      result.to_json(*a)
+    end
+end

data/lib/seamless/dispatcher.rb

@@ -0,0 +1,45 @@
+module Seamless
+    class Dispatcher
+    	include Singleton
+    
+		def serialize(session,body)
+			queue = session['_seamless_mq']
+			body << '<?xml version="1.0"?>'
+			body << "<messages version='1.0' sessionid='#{session.session_id}'>"
+			if queue
+			  queue.each do |msg|
+				body << msg
+			  end
+			  session['_seamless_mq']=[]
+			end
+			body << '</messages>'
+		end
+		
+		def outgoing(obj,type,message)
+			queue = obj['session']['_seamless_mq']
+			if !queue
+			  queue = [];
+			  obj['session']['_seamless_mq'] = queue
+			end
+			#TODO requestid
+			queue << "<message requestid='' direction='OUTGOING' datatype='JSON' type='#{type}'><![CDATA["
+			queue << message.to_json
+			queue << ']]></message>'
+		end
+		
+		def incoming(session,request,response)
+			body = request.env['RAW_POST_DATA']
+			if body
+			   node = REXML::Document.new(body)
+			   node.root.each_element('//message') do |message|
+				  requestid = message.attributes['requestid']
+				  type = message.attributes['type']
+				  text = message.text
+				  msg = JSON.parse(text)
+				  req = {'requestid'=>requestid, 'session'=>session}
+				  MessageBroker.send(req,type,msg)
+			   end
+			end      
+		end
+    end
+end

data/lib/seamless/message_broker.rb

@@ -0,0 +1,12 @@
+#
+# require dependencies
+#
+Dir[File.dirname(__FILE__)+'/messagebroker/*.rb'].sort.each do |file|
+	require file[0..-4]
+end
+
+
+#
+# set the default message broker to the basic in memory message broker
+#
+Seamless::MessageBroker = Seamless::InmemoryMessageBroker.instance

data/lib/seamless/message_broker_controller.rb

@@ -0,0 +1,11 @@
+
+class MessageBrokerController < ActionController::Base    
+		def process(request, response)
+			response.headers['Content-Type'] = 'text/xml' 
+			session = request.session
+			Seamless::Dispatcher.instance.incoming(session,request,response)
+			Seamless::Dispatcher.instance.serialize(session,response.body)
+			session.close
+			response
+		end
+end

data/lib/seamless/messagebroker/inmemory_message_broker.rb

@@ -0,0 +1,45 @@
+#
+# implementation of the message broker which only dispatches
+# messages to internally registered listeners
+#
+#
+module Seamless
+	class InmemoryMessageBroker
+		include Singleton
+
+		def initialize 
+			@listeners={}
+		end	  	
+	
+	  	def register_listener(type,listener)
+			array = @listeners[type]
+			if array==nil
+			  array=[]
+			  @listeners[type]=array
+			end
+			array << listener
+	  	end
+	  	
+	  	def unregister_listener(type,listener)
+	  		array = @listeners[type]
+	  		array.delete_if { |a| a == listener } if array
+	  	end
+	  	
+	  
+	  	def send (req,type,obj)
+			array = @listeners[type]
+			if array
+			  array.each do |listener|
+				begin
+				  listener.call(req,type,obj)
+				rescue => error
+				  puts $!
+				  raise error
+				end
+			  end
+			  return true
+			end
+			false
+	  	end
+	end
+end

data/lib/seamless/migration.rb

@@ -0,0 +1,8 @@
+module ActiveRecord
+	class Migration
+	  def self.add_foreign_key(from_table, from_column, to_table)
+		constraint_name = "fk_#{from_table}_#{from_column}"		
+		execute %{ALTER TABLE #{from_table} ADD CONSTRAINT #{constraint_name} FOREIGN KEY (#{from_column}) REFERENCES #{to_table}(id)}
+	  end
+	end
+end

data/lib/seamless/model.rb

@@ -0,0 +1,94 @@
+begin
+	require 'cached_model'
+end
+
+module Seamless  
+	class Model < ActiveRecord::Base
+		self.abstract_class = true
+		
+		def Model.models
+			SEAMLESS_MODELS
+		end
+		
+		def update
+			super
+			delete_cache if defined?(Cache)
+		end
+		
+		def destroy
+			super
+			delete_cache if defined?(Cache)
+		end
+		
+		private 
+		def delete_cache
+			# delete the PK entry
+			Cache.delete "#{self.class.name}:id:#{quoted_id}"
+		end
+		
+		class << self
+		
+			def log(msg)
+				if logger && logger.level == Logger::DEBUG
+					logger.add(Logger::DEBUG, "Seamless::Model - #{msg}")
+				end
+			end
+			
+			def find_by_sql(*args)
+			
+				return super(args) if not defined?(Cache)
+				return super(args) unless CachedModel.use_memcache? or CachedModel.use_local_cache?
+		
+				# don't cache result of :all
+				return super(args) if args.first =~ /^SELECT \* FROM #{table_name}$/
+				
+				# don't do more complex finds
+				case args.first
+					when Array then
+						return super(args)
+					end
+		
+				# some SQL ends with space
+				sql = args.first.chomp!(" ")
+				log "SQL: #{sql}"
+		
+				if @model_regex==nil
+					@model_regex = /^SELECT \* FROM #{table_name} WHERE \(#{table_name}\.`#{primary_key}` = (\d+)\)$/
+				end
+				
+				# see if this is a single query for the primary key
+				match = @model_regex.match(sql)
+				pk = nil
+				
+				if match
+					# extract the primary key
+					pk = match[1]	
+					
+					# check to see if the record is in the DB with PK
+					if CachedModel.use_memcache?
+						result = Cache.get "#{name}:id:#{pk}"
+						if result
+							log "cache hit: #{name}.#{primary_key} -> #{pk}"
+							result.instance_variable_set(:@new_record,false)
+							return [result]
+						else
+							log "cache miss: #{name}.#{primary_key} -> #{pk}"
+						end
+					end
+				end
+				
+				records = super(args)
+				
+				if CachedModel.use_memcache?
+					# store in cache
+					if pk
+						Cache.put "#{name}:id:#{pk}", records.first, CachedModel.ttl
+						log "cache set: #{name}.#{primary_key} -> #{pk}"
+					end
+				end
+				
+				records
+			end
+		end
+	end
+end

data/lib/seamless/service.rb

@@ -0,0 +1,186 @@
+
+module Seamless
+	class Service
+	  include Singleton
+	  
+	  def Service.handles_message(messagetype,handler,responsetype)
+		  name = messagetype.gsub(/[:]|[\.\s-]/,'_')
+		  self.class_eval <<-end_eval
+			alias_method :_initialize_#{name}, :initialize
+			def initialize
+			  _initialize_#{name}
+			  register("#{messagetype}","#{handler}","#{responsetype}")                          
+			end
+		  end_eval
+	  end
+	
+	  def Service.service_scaffold(model)
+      	  servicename = model_name(model)
+		  self.class_eval <<-end_eval
+			alias_method :_initialize_#{name}, :initialize
+			def initialize
+			  _initialize_#{name}
+			  @model_class = eval("#{model.to_s.camelize}")
+			  %w( create retrieve update delete list assembly search).each do |operation|
+				    messagetype = "seamless.#{servicename}." + operation
+            		request = messagetype + ".request"
+            		response = messagetype + ".response"
+				    register(request,operation,response)
+  					SEAMLESS_SERVICES << {'name'=>name, 'model'=>servicename}
+			  end
+			end
+			
+			def assembly(request,message)
+			  if self.respond_to?(:before_assembly)
+				  request,message = send(:before_assembly,request,message)
+			  end
+			  data = Array.new
+			  @model_class.columns.each do |column|
+			  	  data << {'name'=>column.name,'type'=>column.type, 'limit'=>column.limit, 
+			  	  		   'nullable'=>column.null, 'primary'=>column.primary, 
+			  	  		   'default'=>column.default}
+			  end
+			  response = {'success'=>true,'columns'=>data}
+			  if self.respond_to?(:after_assembly)
+				  response = send(:after_assembly,response)
+			  end
+			  response
+			end
+			
+			def create(request,message)
+			  if self.respond_to?(:before_create)
+				  request,message = send(:before_create,request,message)
+			  end
+			  o = @model_class.new(message)
+			  o.save
+			  response = {'success'=>true,'id'=>o.id}
+			  if self.respond_to?(:after_create)
+				  response = send(:after_create,response)
+			  end
+			  response
+			end
+			
+			def retrieve(request,message)
+			  if self.respond_to?(:before_retrieve)
+				request,message = send(:before_retrieve,request,message)
+			  end
+			  o = @model_class.find(message['id'])
+			  response = {'success'=>true}
+			  o.attributes.each do |key,val|
+				  response[key]=val
+			  end
+			  response
+			  if self.respond_to?(:after_retrieve)
+				  response = send(:after_retrieve,response)
+			  end
+			  response
+			end
+			
+			def update(request,message)
+			  if self.respond_to?(:before_update)
+				request,message = send(:before_update,request,message)
+			  end
+			  o = @model_class.find(message['id'])
+			  return {'success'=>false,'message'=>'record does not exist'} unless o
+			  message.each do |key,value|
+				if o.attributes.has_key?(key)
+				  o[key]=true if value=='true'
+				  o[key]=false if value=='false'
+				  o[key]=value if o[key]!=true && o[key]!=false
+				end
+			  end
+			  o.save!
+			  response = {'success'=>true,'id'=>o.id}
+			  if self.respond_to?(:after_update)
+				  response = send(:after_update,response)
+			  end
+			  response
+			end
+			
+			def delete(request,message)
+			  if self.respond_to?(:before_delete)
+				request,message = send(:before_delete,request,message)
+			  end
+			  @model_class.delete(message['id'])
+			  response = {'success'=>true,'id'=>message['id']}
+			  if self.respond_to?(:after_delete)
+				  response = send(:after_delete,response)
+			  end
+			  response
+			end
+			
+			def search(request,message)
+  			  if self.respond_to?(:before_search)
+  				request,message = send(:before_search,request,message)
+  			  end
+			    query = '%%' + message['query'] + '%%'
+			    conditions_str = Array.new
+			    @model_class.content_columns.each do |col|
+			      name = col.name + ' like ?'
+			      conditions_str << name if col.type == :string
+		      end
+		      
+		      conditions = Array.new
+		      conditions << conditions_str.join(' OR ')
+		      conditions_str.length.times {|e| conditions<<query}
+		      		      
+		      results = @model_class.find(:all,:conditions=>conditions)
+		      response = {'success'=>true, 'rows'=>results, 'total'=>@model_class.count, 'count'=>results.length}
+  			  
+  			  if self.respond_to?(:after_search)
+  				  response = send(:after_search,response)
+  			  end
+  			  response
+		  end
+			
+			def list(request,message)
+			  pk = message['id']
+			  limit = message['limit'] || 100
+			  if pk
+  			    objs = [@model_class.find_by_id(pk)]
+		      else
+  			    objs = @model_class.find(:all,:limit=>limit)
+	      	  end
+			  response = {'success'=>true,'rows'=>objs, 'total'=>@model_class.count}
+			  if self.respond_to?(:after_list)
+				  response = send(:after_list,response)
+			  end
+			  response
+			end
+			
+		  end_eval
+	  end
+	  
+	  private 
+
+	  def register(type,methodname,responsetype = nil)
+		  handler = self.method(methodname)
+		  args = handler.arity
+		  p = Proc.new do |req,type,obj|
+		   
+		   #
+		   # try and be smart about sending in the request to the
+		   # service based on the arguments he supports
+		   # 
+		   case args
+		   	when 2
+		   		resp = handler.call(req,obj)
+		    when 3
+		    	resp = handler.call(req,obj,req['session'])
+		    when 4
+		    	resp = handler.call(req,obj,req['session'],req['session']['username'])
+		   end
+		   
+		   if responsetype
+			  Dispatcher.instance.outgoing(req,responsetype,resp||{})
+		   end
+		end
+		  MessageBroker.register_listener(type,p)
+	  end
+	
+	  def send_message(req,type,message)
+		  MessageBroker.send(req,type,message)
+	  end
+	
+	end
+end