ease_engine 0.0.19

data/benchmark/udp/udp_server.rb

@@ -0,0 +1,33 @@
+require "ease_engine"
+require "./udp_packet"
+
+class BenchmarkApplication < EaseEngine::Application
+  def on_start
+    super
+    
+    @is_update = true
+    EaseEngine::Frame.fps = 60
+    
+    host = ARGV[ 0 ]
+    port = ARGV[ 1 ].to_i
+    
+    udp_socket = EaseEngine::UDPSocket.new
+    udp_socket.bind( host, port )
+    add_socket( udp_socket )
+    
+    EE_LOG_DBG.call "host=#{host} port=#{port}"
+  end
+  
+  def on_update
+    if 1000000 <= @measure.check
+      EE_LOG_DBG.call "watcher.size=#{@watcher.size} update_usec=#{@measure.update_usec} count=#{@measure.count}"
+      
+      @measure.start
+    end
+  end
+  
+  def on_read_socket( socket, packet )
+    write_packet( socket, packet, 0 )
+  end
+end
+BenchmarkApplication::run

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "ease_engine"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start

data/bin/setup

@@ -0,0 +1,7 @@
+#!/bin/bash
+set -euo pipefail
+IFS=$'\n\t'
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ease_engine.gemspec

@@ -0,0 +1,27 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ease_engine/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ease_engine"
+  spec.version       = EaseEngine::VERSION
+  spec.authors       = ["liveralmask"]
+  spec.email         = ["liveralmask.lisk@gmail.com"]
+  spec.license       = "MIT"
+
+  spec.summary       = %q{Easy application programming scripts.}
+  spec.description   = %q{Easy application programming scripts.}
+  spec.homepage      = "https://github.com/liveralmask/ease_engine"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  
+  spec.add_dependency "cool.io"
+  spec.add_dependency "msgpack"
+end

data/lib/ease_engine.rb

@@ -0,0 +1,35 @@
+require "ease_engine/version"
+require "ease_engine/application"
+
+module EaseEngine
+  def self.assert( result, *args )
+    if ! result
+      args = [ "Assert" ] if 0 == args.length
+      raise sprintf( *args )
+    end
+  end
+  
+  def self.rotate( min, max, value, add )
+    return min if value < min || max < value
+    
+    value += add
+    ( value < min || max < value ) ? min : value
+  end
+  
+  def self.trace_info( trace = 0 )
+    trace = caller[ trace ] if ! trace.instance_of?( String )
+    
+    info = {
+      :file   => "",
+      :line   => 0,
+      :method => "",
+    }
+    if /^(.+?):(\d+)(?::in `(.*)')?/ =~ trace
+      info[ :file ]   = $1
+      info[ :line ]   = $2.to_i
+      info[ :method ] = $3
+    end
+    info[ :str ] = "#{info[ :file ]}:#{info[ :line ]} #{info[ :method ]}"
+    info
+  end
+end

data/lib/ease_engine/application.rb

@@ -0,0 +1,269 @@
+require "ease_engine/measure"
+require "ease_engine/frame"
+require "ease_engine/watcher"
+require "ease_engine/packet"
+require "ease_engine/log"
+require "ease_engine/http"
+require "ease_engine/process"
+require "ease_engine/platform"
+require "ease_engine/timer"
+
+module EaseEngine
+  class Application
+    def self.run( options = {} )
+      EaseEngine::Log.inf( "EaseEngine #{EaseEngine::VERSION} options=#{options}" )
+      application = new( options )
+      begin
+        application.on_start
+      rescue => err
+        application.on_error( err )
+        
+        application.is_update = false
+      end
+      
+      while application.is_update
+        begin
+          EaseEngine::Frame.update{|sleep_time_usec, sleep_time_f|
+            application.watcher.watch( sleep_time_f )
+          }
+          application.timer.update
+          application.socket_timer.update
+          application.on_update
+        rescue => err
+          application.on_error( err )
+        end
+      end
+      
+      begin
+        application.on_end
+      rescue => err
+        application.on_error( err )
+      end
+      
+      application.exit_status
+    end
+    
+    attr_accessor   :options
+    attr_accessor   :exit_status, :is_update
+    attr_accessor   :watcher, :measure
+    attr_accessor   :timer, :socket_timer
+    attr_accessor   :is_daemon
+    
+    def initialize( options )
+      @options = options
+      if ! @options.key?( :watcher )
+        @options[ :watcher ] = {}
+      end
+      if ! @options.key?( :timer )
+        @options[ :timer ] = {}
+      end
+      if ! @options.key?( :socket_timer )
+        @options[ :socket_timer ] = {
+          :connect_timeout_usec   => 10000000,
+          :connected_timeout_usec => 10000000,
+        }
+      end
+      @options[ :is_daemon ] = false if ! @options.key?( :is_daemon )
+      
+      @exit_status = 0
+      @is_update = false
+      
+      @watcher = EaseEngine::Watcher.new( @options[ :watcher ] )
+      @measure = EaseEngine::Measure.new
+      @timer = EaseEngine::Timer.new( @options[ :timer ] )
+      @socket_timer = EaseEngine::Timer.new( @options[ :socket_timer ] )
+      
+      @is_daemon = @options[ :is_daemon ]
+    end
+    
+    def on_start
+      trap( :INT ){
+        @is_update = false
+        @exit_status = :INT
+      }
+      
+      trap( :TERM ){
+        @is_update = false
+        @exit_status = :TERM
+      }
+      
+      trap( :PIPE ){}
+    end
+    
+    def on_update
+    end
+    
+    def on_end
+      @watcher.each{|info|
+        @watcher.remove( info.io )
+      }
+    end
+    
+    def on_accept_socket( socket )
+      accepted_socket = socket.accept
+      if ! socket.err.nil?
+        on_error_socket( socket )
+        return
+      end
+      
+      add_socket( accepted_socket )
+      on_accepted_socket( accepted_socket, socket )
+    end
+    
+    def on_accepted_socket( accepted_socket, server_socket )
+    end
+    
+    def on_connected_socket( socket )
+    end
+    
+    def on_read_socket( socket, packet )
+    end
+    
+    def on_close_socket( socket )
+    end
+    
+    def on_timeout_socket( socket )
+      EaseEngine::Log.wrn( "on_timeout_socket #{socket}" )
+    end
+    
+    def on_error_socket( socket )
+      EaseEngine::Log.err( "on_error_socket #{socket} #{socket.err.class.name}: #{socket.err}\n#{socket.err.backtrace}" )
+    end
+    
+    def on_error( err )
+      EaseEngine::Log.err( "on_error #{err.class.name}: #{err}\n#{err.backtrace}" )
+    end
+    
+    def add_server_socket( socket )
+      application = self
+      @watcher.add( socket, {
+        :on_read => Proc.new{|socket|
+          application.on_accept_socket( socket )
+        },
+        :on_remove => Proc.new{|socket|
+          application.close_socket( socket )
+        }
+      })
+    end
+    
+    def add_socket( socket )
+      application = self
+      @watcher.add( socket, {
+        :on_read => Proc.new{|socket|
+          application.read_socket( socket )
+        },
+        :on_remove => Proc.new{|socket|
+          application.close_socket( socket )
+        }
+      })
+    end
+    
+    def add_connect_socket( socket )
+      application = self
+      @watcher.add( socket, {
+        :on_read => Proc.new{|socket|
+          socket.err = SystemCallError.new( socket.errno )
+          application.on_error_socket( socket )
+          application.remove_socket( socket )
+        },
+        :on_write => Proc.new{|socket|
+          application.remove_socket_timer( socket.to_i )
+          
+          socket.err = nil
+          application.add_socket( socket )
+          application.on_connected_socket( socket )
+          
+          if socket.is_heartbeat
+            # connected timeout
+            hash = {
+              :socket       => socket,
+              :timeout_usec => @options[ :socket_timer ][ :connected_timeout_usec ],
+            }
+            hash[ :callback ] = Proc.new{|hash|
+              if hash[ :socket ].is_timeout
+                application.timeout_socket( hash[ :socket ] )
+                next
+              end
+              
+              hash[ :socket ].is_timeout = true
+              application.write_packet( socket, EaseEngine::HeartbeatBeginPacket.new )
+              application.add_socket_timer( hash[ :socket ].to_i, hash[ :timeout_usec ], hash, hash[ :callback ] )
+            }
+            hash[ :callback ].call( hash )
+          end
+        },
+        :on_remove => Proc.new{|socket|
+          application.close_socket( socket )
+        }
+      })
+      
+      # connect timeout
+      add_socket_timer( socket.to_i, @options[ :socket_timer ][ :connect_timeout_usec ], socket, Proc.new{|socket|
+        application.timeout_socket( socket )
+      })
+    end
+    
+    def remove_socket( socket )
+      @watcher.remove( socket )
+    end
+    
+    def read_socket( socket )
+      Packet.creates( socket ).each{|packet|
+        case packet.packet_name
+        when "EaseEngine.HeartbeatBeginPacket"
+          write_packet( socket, EaseEngine::HeartbeatEndPacket.new )
+        when "EaseEngine.HeartbeatEndPacket"
+        else
+          on_read_socket( socket, packet )
+        end
+      }
+      check_socket( socket )
+    end
+    
+    def write_packet( socket, packet, flags = 0, *args )
+      packet.write( socket, flags, *args )
+    end
+    
+    def reflect_socket( socket, recv_flags = 0, send_flags = 0 )
+      buf = socket.recv( socket.read_max_size, recv_flags )
+      if ! buf.empty?
+        result = socket.send( buf, send_flags )
+        return if result == buf.length
+        EaseEngine::Log.err( "reflect_socket #{result} != #{buf.length}" ) if 0 < result && result != buf.length
+      end
+      check_socket( socket )
+    end
+    
+    def check_socket( socket )
+      on_error_socket( socket ) if ! socket.err.nil?
+      remove_socket( socket ) if socket.is_disable
+    end
+    
+    def timeout_socket( socket )
+      on_timeout_socket( socket )
+      remove_socket( socket )
+    end
+    
+    def close_socket( socket )
+      remove_socket_timer( socket.to_i )
+      on_close_socket( socket )
+      socket.close
+    end
+    
+    def add_timer( group_id, timeout_usec, arg, callback )
+      @timer.add( group_id, timeout_usec, arg, callback )
+    end
+    
+    def remove_timer( group_id, timer_id = 0 )
+      @timer.remove( group_id, timer_id )
+    end
+    
+    def add_socket_timer( socket_id, timeout_usec, arg, callback )
+      @socket_timer.add( socket_id, timeout_usec, arg, callback )
+    end
+    
+    def remove_socket_timer( socket_id, timer_id = 0 )
+      @socket_timer.remove( socket_id, timer_id )
+    end
+  end
+end

data/lib/ease_engine/buffer.rb

@@ -0,0 +1,25 @@
+module EaseEngine
+  class Buffer
+    attr_accessor   :value, :size
+    
+    def initialize( value = "" )
+      @value = value
+      @size = value.length
+    end
+    
+    def <<( value )
+      if ! value.empty?
+        @value << value
+        @size += value.length
+      end
+      @value
+    end
+    
+    def >>( size )
+      return "" if size <= 0
+      
+      @size -= size
+      @value.slice!( 0, size )
+    end
+  end
+end

data/lib/ease_engine/data.rb

@@ -0,0 +1,158 @@
+module EaseEngine
+  module Data
+    class Hary
+      class Info
+        attr_accessor   :id, :index, :data
+        
+        def initialize( id, index, data )
+          @id = id
+          @index = index
+          @data = data
+        end
+      end
+      
+      def initialize
+        @ary = []
+        @indexes = {}
+      end
+      
+      def add( id, data )
+        if ! @indexes.key?( id )
+          info = Info.new( id, @ary.size, data )
+          @ary.push info
+          @indexes[ id ] = info.index
+        else
+          info = @ary[ @indexes[ id ] ]
+          info.id = id
+          info.data = data
+        end
+        
+        sort!
+        id
+      end
+      
+      def remove( id )
+        remove_at( @indexes[ id ] ) if @indexes.key?( id )
+      end
+      
+      def remove_at( index )
+        return nil if @ary.size <= index
+        
+        info = @ary[ index ]
+        @ary.delete_at( index )
+        @indexes.delete( info.id )
+        update if index != @ary.size # 末尾データの削除なら、更新しない
+        info.data
+      end
+      
+      def get( id )
+        @indexes[ id ]
+      end
+      
+      def get_at( index )
+        ( @ary.size <= index ) ? nil : @ary[ index ]
+      end
+      
+      def key?( id )
+        @indexes.key?( id )
+      end
+      
+      def size
+        @ary.size
+      end
+      
+      def each
+        @ary.each{|info|
+          yield info.id, info.index, info.data
+        }
+      end
+      
+      def update
+        @ary.each_with_index{|info, index|
+          info.index = index
+          @indexes[ info.id ] = index
+        }
+      end
+      
+      def sort!
+        update
+      end
+    end
+    
+    class Record < Hary
+      def initialize( min, max )
+        @min = min
+        @max = max
+        @id = min
+        
+        super()
+      end
+      
+      def add( data )
+        @id = generate_id( @id )
+        return 0 if 0 == @id
+        
+        super( @id, data )
+      end
+      
+    protected
+      def generate_id( id )
+        generated_id = 0
+        start_id = id
+        begin
+          generated_id = id if ! key?( id )
+          
+          id = EaseEngine::rotate( @min, @max, id, 1 )
+        end while 0 == generated_id && start_id != id
+        generated_id
+      end
+    end
+    
+    class Group
+      def initialize
+        @group = {}
+        @data = {}
+      end
+      
+      def add( group_id, data_id )
+        if @group.key?( group_id )
+          @group[ group_id ][ data_id ] = group_id
+        else
+          @group[ group_id ] = {
+            data_id => group_id
+          }
+        end
+        
+        if @data.key?( data_id )
+          @data[ data_id ][ group_id ] = data_id
+        else
+          @data[ data_id ] = {
+            group_id => data_id
+          }
+        end
+      end
+      
+      def remove( group_id, data_id )
+        if @group.key?( group_id )
+          @group[ group_id ].each{|data_id, group_id|
+            @data.delete( data_id )
+          }
+          @group.delete( group_id )
+        elsif @data.key?( data_id )
+          @data[ data_id ].each{|group_id, data_id|
+            @group[ group_id ].delete( data_id )
+          }
+          @data.delete( data_id )
+        end
+      end
+      
+      def group( group_id )
+        @group.key?( group_id ) ? @group[ group_id ] : {}
+      end
+      
+      def data( data_id )
+        @data.key?( data_id ) ? @data[ data_id ] : {}
+      end
+    end
+  end
+end