dango 0.0.1

data/Manifest.txt

@@ -0,0 +1,13 @@
+Manifest.txt
+README.txt
+lib/dango/client_framework.rb
+lib/dango/framework_base.rb
+lib/dango/server_framework.rb
+lib/dango/monitor/dango_monitor_client.rb
+lib/dango/script/dango_server.rb
+lib/dango/shared/memory_store.rb
+lib/dango/tasks/dango_rake.rb
+lib/dango/version.rb
+setup.rb
+test/test_helper.rb
+test/test_dango.rb

data/README.txt

@@ -0,0 +1,47 @@
+= dango -- Ruby - Flash conneciton network flamework
+
+
+== Download
+
+The latest version of dango can be found at
+
+* http://rubyforge.org/frs/?group_id=****
+
+== Installation
+
+=== Normal Installation
+
+You can install dango with the following command.
+
+  % ruby setup.rb
+
+from its distribution directory.
+
+=== GEM Installation
+
+Download and install  dango with the following.
+
+   gem install dango
+
+== dango References
+
+* dango Project Page: http://rubyforge.org/projects/dango
+* dango API Documents: http://dango.rubyforge.org
+
+== Simple Example
+
+  ruby "rubygems" # you use rubygems
+  ruby "image_size"
+  ruby "open-uri"
+  open("http://www.rubycgi.org/image/ruby_gtk_book_title.jpg", "rb") do |fh|
+    p ImageSize.new(fh.read).get_size
+  end
+
+== Licence
+
+This code is free to use under the terms of the Ruby's licence. 
+
+== Contact
+
+Comments are welcome. Send an email to "Keisuke Minami":mailto:keisuke@rccn.com
+

data/lib/dango/client_framework.rb

@@ -0,0 +1,260 @@
+#!ruby -Ku
+
+=begin
+= コネクション型クライアントフレームワーク
+=end
+
+require "dango/framework_base"
+
+# フレームワーククラス
+class DangoClientFramework
+  include DangoFrameworkModule
+  
+  SendReceiveSleepIntervalSec = 0.1 # データ送信後の順の際のタイムアウトチェック間隔秒
+  
+  # cs_client_send_receive_data用の共有メモリ
+  def send_receive_shared_init
+    @send_receive_shared = SharedMemoryStore.new
+  end
+  def send_receive_shared
+    @send_receive_shared
+  end
+  
+  # 起動処理
+  def cs_client_init
+  end
+  
+  # セッションが切れると呼ばれる処理
+  def cs_session_closed
+  end
+  
+  # メイン処理
+  def initialize(env, config = nil)
+    if !config
+      config = YAML.load(open("dango/config/#{env}.yml", "rb"){|fh| fh.read})
+    end
+    
+    @config = config
+    
+    # 変数の初期設定
+    @connection_client_host = @config['client']['host'] || 'localhost'
+    @connection_client_port = @config['network']['port'] || 15000
+    
+    @connection_client_host = 'localhost'         # 未定義時にこのホスト名でサーバー開始
+    @connection_client_port = 15000               # 未定義時にこのポートでサーバー開始
+    @connection_client_log_file = ""              # 未定義時にこのログファイル名を使う
+    @connection_client_log_level = Logger::DEBUG  # 未定義時にこのログレベルになる
+    
+    @recv_count = 0 # 受信回数
+    @send_count = 0 # 送信回数
+    
+    Signal.trap('INT') do # SIGINT を捕捉する。
+      puts "shutdown"
+#     exit
+      exit!
+    end
+    
+    cs_client_init() # 初期設定読み込み
+    
+    @log_file = @connection_client_log_file
+    @log_level = @connection_client_log_level
+    
+    # loggerの準備
+    cs_logger.debug("client initialize")
+    
+    # データ送受信用の共有メモリ初期化
+    send_receive_shared_init()
+    @send_receive_mutex = Mutex.new # 送受信用の排他処理
+    
+    # 通知共有メモリの初期化
+    cs_client_notice_shared_init()
+    
+    # ソケットの準備
+    @sock = nil
+    
+    # サーバーへ接続
+    begin
+      @sock = TCPSocket.new(@connection_client_host, @connection_client_port)
+    rescue Errno::EBADF
+      raise DangoFrameworkConnectionError
+    end
+    
+    @sock.binmode
+    @sock.sync = true
+    @tmutex = Mutex.new # sockの排他処理用
+    cs_logger.debug("addr:#{@sock.addr.inspect}")
+    
+    # データ受信用のスレッドの開始
+    @thread_receive = Thread.start{ thread_main() }
+  end
+  
+  # データ受信用のスレッド処理
+  def thread_main()
+    catch(:session_closed) do
+      loop do
+        begin
+          if @sock
+            cs_logger.debug "start receive_data"
+            ret_obj = nil
+            begin
+              ret_obj = cs_receive_data(@sock) # データ受信処理
+            rescue DangoFrameworkConnectionError
+              cs_logger.debug "sock error:#{error_message($!, 'u')}"
+              throw(:session_closed)
+            rescue DangoFrameworkError
+              cs_logger.debug "sock error:#{error_message($!, 'u')}"
+              throw(:session_closed)
+            end
+            cs_logger.debug "finished cs_receive_data:#{ret_obj.inspect}"
+            
+            if !(ret_obj && ret_obj["notice"])
+              cs_logger.info "no notice:#{ret_obj["notice"].inspect}"
+            end
+            
+            # メソッド呼び出し
+            cs_logger.info "calling method=#{ret_obj["notice"].inspect}"
+            begin
+              __send__("cs_receive_#{ret_obj["notice"]}", ret_obj)
+            rescue
+              cs_logger.error "error in cs_receive_#{ret_obj["notice"]}\n#{error_message($!, 'u')}"
+            end
+            cs_logger.debug "called method=#{ret_obj["notice"].inspect}"
+            
+          else
+            sleep 0.1
+          end
+          
+        rescue Exception
+          cs_logger.debug "#{error_message($!, 'u')}"
+        end
+      end
+    end
+    
+    client_quit() # クライアントの終了処理
+  end
+  private :thread_main
+  
+  # ユーザーが終了させたい時に呼び出すメソッド（セッションを切る）
+  def cs_client_close
+    client_quit() # クライアントの終了処理
+  end
+  
+  # クライアントの終了処理
+  def client_quit()
+    begin
+      @sock.close if @sock
+    rescue
+      cs_logger.debug "sock close failed. #{$!}"
+    end
+    @sock = nil
+    
+    @is_session_closed = true
+    cs_logger.info "calling cs_session_closed()"
+    cs_session_closed() # セッションが切れると呼ばれる処理
+  end
+  private :client_quit
+  
+  # クライアントの暗号化処理
+  def cs_client_send_encrypt(str) # 継承用
+    str
+  end
+  def cs_send_encrypt(str) # フレームワークから呼ばれる部分
+    cs_client_send_encrypt(str)
+  end
+  
+  # クライアントの復号化処理
+  def cs_client_receive_decrypt(str) # 継承用
+    str
+  end
+  def cs_receive_decrypt(str) # フレームワークから呼ばれる部分
+    cs_client_receive_decrypt(str)
+  end
+  
+  # クライアントからサーバーへのデータ送信
+  def cs_client_send_data(action_name, send_obj)
+    send_obj_dup = send_obj.dup
+    send_obj_dup["action"] = action_name.to_s
+    cs_send_data(@sock, send_obj_dup)
+  end
+  
+  # サーバーからクライアントへのデータ送信
+  # 自動でreturn_nameに対応したcs_receive_メソッドが出来上がるので注意
+  # options = {:return_name=> :timeout => }
+  # return_nameは省略時は、action_nameの頭にreturnを付けたもののシンボルになる
+  # timeoutは省略時は6秒
+  def cs_client_send_receive_data(action_name, send_obj, options = {})
+    cs_logger.debug "cs_client_send_receive_data(#{action_name.inspect}, #{send_obj.inspect}, #{options.inspect})"
+    
+    return_name = options[:return_name] || ("return_" + action_name.to_s).to_sym
+    timeout = options[:timeout] || 6
+    
+    @send_receive_mutex.synchronize do
+      send_receive_shared[action_name] = nil
+      
+      receive_thread = nil
+      end_reserved_time = Time.now + timeout
+      
+      # 戻ってきたデータのチェック
+      action_name_sym = (action_name.class == Symbol) ? (":"+action_name.to_s) : ('"'+action_name+'"')
+      instance_method_name = "cs_receive_#{return_name}"
+      expr = <<-EOF
+        def self.#{instance_method_name}(ret_obj)
+          cs_logger.debug "ret_obj:" + ret_obj.inspect
+          send_receive_shared[#{action_name_sym}] = ret_obj
+        end
+      EOF
+      instance_eval expr
+      
+      # タイムアウトチェック
+      (timeout.to_f / SendReceiveSleepIntervalSec).to_i.times do
+        raise(DangoFrameworkTimeoutError, "timeout:#{action_name}") if Time.now > end_reserved_time
+        
+        # 送信スレッドが開始していなければ開始
+        if !receive_thread
+          receive_thread = Thread.start do
+            cs_client_send_data(action_name, send_obj)
+          end
+        end
+        
+        # 戻ってきたデータがあれば
+        if send_receive_shared[action_name]
+          cs_logger.debug "action_name:#{send_receive_shared[action_name].inspect}"
+          break 
+        end
+        
+        sleep SendReceiveSleepIntervalSec # スリープ
+      end
+      
+      if !send_receive_shared[action_name] # 戻ってきたデータがあるかどうかチェック
+        raise(DangoFrameworkError, "received data is none") 
+      end
+      
+      #remove_method(instance_method_name) # 定義したインスタンスメソッドを削除しておく
+      
+      send_receive_shared[action_name]
+    end
+  end
+  
+  # 通知共有メモリ情報の書き換えクラス
+  class ClientNoticeShared
+    def initialize(parent)
+      @parent = parent
+    end
+    
+    def []=(key, value) # キーに対する書き込み（読み込みはないぞ）
+      action_name = "action_notice_shared_#{key}"
+      send_obj = {:data => value}
+      @parent.cs_client_send_data(action_name, send_obj)
+    end
+  end
+  
+  def cs_client_notice_shared_init # 通知共有メモリの初期化
+    @client_notice_shared = ClientNoticeShared.new(self)
+  end
+  
+  def cs_client_notice_shared # 通知共有メモリ
+    @client_notice_shared
+  end
+  
+end
+

data/lib/dango/framework_base.rb

@@ -0,0 +1,247 @@
+#!ruby -Ku
+
+=begin
+= コネクションのサーバー、クライアントで使うモジュール
+=end
+
+require "rubygems"
+
+require 'logger'
+require 'socket'
+require 'thread'
+require 'timeout'
+require 'yaml'
+require "stringio"
+require "pp"
+require "kconv"
+require "fcntl"
+require "json"
+
+require "dango/shared/memory_store.rb"
+
+
+class Object
+  # 1.8.5では実装済みの機能を1.8.4でも使えるようにしたもの
+  if RUBY_VERSION < '1.8.5'
+    def pretty_inspect
+      str = StringIO.open("", "w+") do |sio| 
+        PP.pp(self, sio)
+        sio.rewind
+        sio.read
+      end
+      
+      str
+    end
+  end
+
+  def deep_dup
+    Marshal.load(Marshal.dump(self))
+  end
+end
+
+# Timeクラスの表示形式修正
+#class Time
+#  def to_s
+#    self.strftime("%Y-%m-%d %H:%M:%S")
+#  end
+#end
+
+# 例外定義
+class DangoFrameworkError < StandardError; end
+class DangoFrameworkTimeoutError < DangoFrameworkError; end
+class DangoFrameworkConnectionError < DangoFrameworkError; end
+
+# エラー出力用モジュール
+module ErrorMessage
+  # デバッグ出力用のメソッド
+  def error_message(exception_class, code = nil)
+    if exception_class.kind_of?(Exception)
+      "#{exception_class.class} is not Exception class"
+    end
+    
+    str = "#{exception_class.class}:#{exception_class.message}\n#{exception_class.backtrace.pretty_inspect}"
+    if code.downcase == "u" || code.downcase == "utf8"
+      str = str.toutf8
+    elsif code.downcase == "s" || code.downcase == "sjis"
+      str = str.tosjis
+    end
+    str
+  end
+end
+
+# ユーティティ
+module DangoUtilModule
+  # 配列をランダムに並べ替え
+  # arrは順番を入れ替えたい配列
+  # numは入れ替え回数（省略時2、大きな数を入れると確実にランダムになるが時間が掛かる）
+  def array_random(arr, num = 2)
+		arr.sort_by{rand}
+
+#    ret_arr = arr.deep_dup
+#    (ret_arr.size * num).times do # メンバー数のnum倍の回数、入れ替え
+#      idx = rand(ret_arr.size)
+#      id = ret_arr.delete_at(idx)
+#      ret_arr.push(id)
+#    end
+#    ret_arr
+  end
+end
+
+# クライアントとサーバーで共有するモジュール
+module DangoFrameworkModule
+  include ErrorMessage
+  
+  CommMaxDigit = 5                 # 通信の最大桁数
+  MaxLen       = 1024              # 通信の一度の送信バイト数
+  
+  DefaultDataType = 0              # デフォルトのデータのタイプ
+  
+  # 0 = JSON
+  # 1 = YAML
+  # 2 = Marshal
+  
+  # デバッグ出力用のメソッド
+  def cs_debug_print(str)
+    cs_logger.debug str
+    puts str if $VERBOSE
+  end
+  
+  # ロガーの定義
+  def cs_logger
+#   if !@cs_logger                                            # これだと警告が出てうざいので
+    if !self.instance_variables.find{|iv| iv == '@cs_logger'} # @cs_loggerが未定義なら
+      if @log_file != ""
+        log_dir = File.dirname(@log_file)
+        Dir.mkdir(log_dir) if !File.exist?(log_dir)
+        @cs_logger = Logger.new(@log_file)
+        @cs_logger.level = @log_level
+#        @cs_logger.datetime_format = "%Y-%m-%dT%H:%M:%S"
+        @cs_logger.datetime_format = "aaaaa"
+        @cs_logger.progname = "#{Thread.current.object_id}"
+      end
+    end
+    @cs_logger
+  end
+
+  # データ受信処理
+  def cs_receive_data(sock)
+    ret_data = ""
+    
+    cs_logger.debug "receive_data(#{sock})"
+    
+    begin
+#      size_str = sock.readpartial(CommMaxDigit + 1)
+#      size_str = sock.sysread(CommMaxDigit + 1)
+      size_str = sock.recv(CommMaxDigit + 1)
+    rescue EOFError
+      # EOFErrorはその接続終了時の切断と思われるのでDangoFrameworkConnectionErrorにしない
+      #raise(DangoFrameworkError, "failed to read sock for EOF reached.\n#{error_message($!, 'u')}")
+      raise(DangoFrameworkError, "failed to read sock for EOF reached.")
+    rescue
+      raise(DangoFrameworkConnectionError, "failed to read sock.\n#{error_message($!, 'u')}")
+    end
+    
+    dtype, size = size_str[0, 5].unpack("cN")
+    
+    raise(DangoFrameworkError, "size=0:size_str=#{size_str.inspect}") if size == 0
+    
+    cs_logger.debug "size=#{size}:size_str=#{size_str.inspect}"
+    
+    ret_data_orig = ""
+    
+    while size > 0
+      read_len = MaxLen > size ? size : MaxLen
+      begin
+#        this_ret_data_orig = sock.readpartial(read_len)
+#        this_ret_data_orig = sock.sysread(read_len)
+        this_ret_data_orig = sock.recv(read_len)
+      rescue
+        raise(DangoFrameworkConnectionError, "failed to read sock(data).\n#{error_message($!, 'u')}")
+      end
+      
+      ret_data_orig += this_ret_data_orig
+#      cs_logger.debug "size:#{size.inspect}:this_ret_data_orig:#{this_ret_data_orig.inspect}"
+      
+      size -= this_ret_data_orig.size
+#      cs_logger.debug "size:#{size.inspect}"
+    end
+    
+#    cs_logger.debug "ret_data_orig:#{ret_data_orig.inspect}"
+    
+    ret_data = cs_receive_decrypt(ret_data_orig[0..-2])
+    
+    @recv_count += 1 if @recv_count # 受信回数カウント
+#    cs_logger.debug "ret_data:#{ret_data.inspect}"
+    
+    begin
+      if ret_data == "\n" # データが空ならparseしない
+        data = {}
+      elsif dtype == 0
+        data = JSON.parse(ret_data)
+      elsif dtype == 1
+        data = YAML::load(ret_data)
+      elsif dtype == 2
+        data = Marshal.load(ret_data)
+      end
+    rescue
+      raise(DangoFrameworkError, "data parse error.\nret_data=#{ret_data}")
+    end
+  end
+  
+  # データ送信処理
+  def cs_send_data(sock, send_obj, options = {})
+    cs_logger.debug "cs_send_data"
+    
+    dtype = options[:type] || DefaultDataType
+    
+    if send_obj == {}
+      send_data_orig = ""
+    elsif dtype == 0
+      send_data_orig = JSON.generate(send_obj)
+    elsif dtype == 1
+      send_data_orig = send_obj.to_yaml
+    elsif dtype == 2
+      send_data_orig = Marshal.dump(send_obj)
+    end
+    
+    send_data = cs_send_encrypt(send_data_orig) + "\n"
+#    send_data = cs_send_encrypt(send_data_orig) + "\r\n"
+#    send_data = cs_send_encrypt(send_data_orig) + "\015\012"
+    
+#    cs_logger.debug "start send_data:#{send_data.inspect}"
+    
+    size = send_data.size
+    
+    if size >= 4294967296
+      raise(DangoFrameworkError, "max size over. size:#{size} >= 4294967296") 
+    end
+    
+#    size_str = sprintf("%0#{CommMaxDigit}d", size)
+    
+    size_str = [dtype, size].pack("cN")
+#    cs_logger.debug "size=#{size}:size_str=#{size_str.inspect}"
+    
+    send_buf = size_str + "\n" + send_data
+#    cs_logger.debug "send_buf:#{send_buf.inspect}"
+    
+    begin
+#      sock.write send_buf
+#      sock.flush
+
+#      sock.send(size_str + "\n", 0)
+#      sock.flush
+#      sock.send(send_data, 0)
+#      sock.flush
+
+      sock.send(send_buf, 0)
+      sock.flush
+    rescue
+      raise(DangoFrameworkConnectionError, "sock write failed.\n#{error_message($!, 'u')}")
+    end
+    
+    @send_count += 1 if @send_count # 受信回数カウント
+#    cs_logger.debug "finish send_data:#{send_data.inspect}"
+    sock
+  end
+end
+