ease_engine 0.0.19

data/lib/ease_engine/frame.rb

@@ -0,0 +1,38 @@
+require "ease_engine/measure"
+
+module EaseEngine
+  class Frame
+    @@fps = 0
+    @@measure = EaseEngine::Measure.new
+    @@offset_usec = 0 # sleep が意図した時間分 sleep するとは限らないので、遅延分を次の sleep 時間から引くためのオフセット値
+    
+    def self.fps=( fps )
+      @@fps = fps
+    end
+    
+    def self.fps
+      @@fps
+    end
+    
+    def self.update( &block )
+      if 0 == @@fps
+        block.call( 0, 0.0 )
+      else
+        @@measure.check
+        sleep_time_usec = 1000000 / @@fps - @@measure.update_usec + @@offset_usec
+        sleep_time_usec = 0 if sleep_time_usec < 0
+        
+        @@measure.start
+        @@offset_usec = sleep_time_usec
+        begin
+          measure = EaseEngine::Measure.new
+          sleep_time_f = sleep_time_usec.to_f / 1000000
+          block.call( sleep_time_usec, sleep_time_f )
+          sleep_time_usec -= measure.check
+        end while 0 < sleep_time_usec
+        @@offset_usec -= @@measure.check
+        @@measure.start
+      end
+    end
+  end
+end

data/lib/ease_engine/http.rb

@@ -0,0 +1,42 @@
+require "net/http"
+
+module EaseEngine
+  class HTTP
+    def self.parse( url )
+      uri = URI.parse url
+      uri
+    end
+    
+    def self.is_ssl( uri )
+      "https" == uri.scheme
+    end
+    
+    def self.get( url, params = {} )
+      uri = self.parse url
+      uri.query = URI.encode_www_form( params )
+      request = Net::HTTP::Get.new uri
+      http = Net::HTTP.new( uri.host, uri.port )
+      response = http.start{|http|
+        http.use_ssl = self.is_ssl( uri )
+        http.request request
+      }
+      
+      case response
+      when Net::HTTPRedirection
+        response = self.get response[ "location" ]
+      end
+      response
+    end
+    
+    def self.post( url, params = {} )
+      uri = self.parse url
+      request = Net::HTTP::Post.new uri
+      request.set_form_data( params )
+      response = Net::HTTP.start( uri.host, uri.port ){|http|
+        http.use_ssl = self.is_ssl( uri )
+        http.request request
+      }
+      response
+    end
+  end
+end

data/lib/ease_engine/log.rb

@@ -0,0 +1,109 @@
+require "ease_engine/time"
+require "fileutils"
+
+module EaseEngine
+  module Log
+    FLAG_DBG  = 0x1
+    FLAG_INF  = 0x2
+    FLAG_WRN  = 0x4
+    FLAG_ERR  = 0x8
+    FLAG_ALL  = FLAG_DBG | FLAG_INF | FLAG_WRN | FLAG_ERR
+    
+    class IO
+      attr_accessor     :file, :flags
+      
+      def initialize( file, flags = FLAG_ALL )
+        @file = file
+        @flags = flags
+      end
+      
+      def write( time, msg )
+        @file.puts "#{time} #{msg}"
+        @file.flush
+      end
+      
+      def close
+        @file.close
+      end
+    end
+    
+    class RotateFile < EaseEngine::Log::IO
+      attr_accessor     :max_size
+      
+      def initialize( file, flags = FLAG_ALL, max_size = 1024 * 1024 )
+        super( file, flags )
+        
+        @max_size = max_size
+      end
+      
+      def rotate( file_path )
+        @file.rewind
+        FileUtils.copy_stream( @file, file_path )
+        @file.truncate( 0 )
+      end
+    end
+    
+    class DailyRotateFile < RotateFile
+      def initialize( *args )
+        super( *args )
+        
+        @check_time = EaseEngine::Time.new
+      end
+      
+      def write( time, msg )
+        on_daily( time ) if is_daily( time )
+        
+        super( time, msg )
+      end
+      
+      def is_daily( time )
+        ! @check_time.is_same_day( time ) && @max_size <= @file.size
+      end
+      
+      def on_daily( time )
+        rotate( sprintf( "%s_%04d%02d%02d", @file.path, @check_time.year, @check_time.month, @check_time.day ) )
+        @check_time = time
+      end
+    end
+    
+    @@files = [ Log::IO.new( $stdout ) ]
+    
+    def self.files=( files )
+      @@files = files
+    end
+    
+    def self.files
+      @@files
+    end
+    
+    def self.output( flags, msg )
+      time = EaseEngine::Time.new
+      @@files.each{|io|
+        next if 0 == flags & io.flags
+        
+        io.write( time, msg )
+      }
+    end
+    
+    def self.dbg( msg )
+      self.output( FLAG_DBG, "DBG #{msg}" )
+    end
+    
+    def self.inf( msg )
+      self.output( FLAG_INF, "INF #{msg}" )
+    end
+    
+    def self.wrn( msg )
+      self.output( FLAG_WRN, "WRN #{msg}" )
+    end
+    
+    def self.err( msg )
+      self.output( FLAG_ERR, "ERR #{msg}" )
+    end
+  end
+end
+
+EE_LOG_DBG = Proc.new{|msg| EaseEngine::Log.dbg( "#{msg} #{EaseEngine::trace_info( 2 )[ :str ]}" ) }
+EE_LOG_INF = Proc.new{|msg| EaseEngine::Log.inf( "#{msg} #{EaseEngine::trace_info( 2 )[ :str ]}" ) }
+EE_LOG_WRN = Proc.new{|msg| EaseEngine::Log.wrn( "#{msg} #{EaseEngine::trace_info( 2 )[ :str ]}" ) }
+EE_LOG_ERR = Proc.new{|msg| EaseEngine::Log.err( "#{msg} #{EaseEngine::trace_info( 2 )[ :str ]}" ) }

data/lib/ease_engine/measure.rb

@@ -0,0 +1,25 @@
+require "ease_engine/time"
+
+module EaseEngine
+  class Measure
+    attr_accessor   :start_time, :end_time, :update_usec, :count
+    
+    def initialize
+      start
+    end
+    
+    def start
+      @start_time = @end_time = EaseEngine::Time.new
+      @update_usec = 0
+      @count = 0
+    end
+    
+    def check
+      @end_time = EaseEngine::Time.new
+      @update_usec += ( @end_time - @start_time )
+      @count += 1
+      @start_time = @end_time
+      @update_usec
+    end
+  end
+end

data/lib/ease_engine/packet.rb

@@ -0,0 +1,150 @@
+require "ease_engine/socket"
+require "msgpack"
+
+module EaseEngine
+  class Packet
+    def self.pack_uint8( value )
+      [ value ].pack( "C" )
+    end
+    
+    def self.pack_uint16( value )
+      [ value ].pack( "v" )
+    end
+    
+    def self.pack_uint32( value )
+      [ value ].pack( "V" )
+    end
+    
+    def self.pack_str( value )
+      [ value ].pack( "Z*" )
+    end
+    
+    def self.unpack_uint8( buf )
+      ( 1 != buf.length ) ? 0 : buf.unpack( "C" )[ 0 ]
+    end
+    
+    def self.unpack_uint16( buf )
+      ( 2 != buf.length ) ? 0 : buf.unpack( "v" )[ 0 ]
+    end
+    
+    def self.unpack_uint32( buf )
+      ( 4 != buf.length ) ? 0 : buf.unpack( "V" )[ 0 ]
+    end
+    
+    def self.unpack_str( buf )
+      buf.unpack( "Z*" )[ 0 ]
+    end
+    
+    def self.creates( socket )
+      packets = []
+      
+      if ! socket.recv( socket.read_max_size ).empty?
+        while true
+          packet = self.create( socket )
+          break if packet.nil?
+          
+          packets.push packet
+        end
+      end
+      
+      packets
+    end
+    
+    def self.create( socket )
+      # 受信したデータから動的にパケットクラスを生成
+      begin
+        size = self.unpack_uint32( socket.read_buf.value.slice( 0, 4 ) )
+        break if ! socket.err.nil?
+        break if 0 == size
+        break if socket.read_buf.size < 4 + size
+        
+        socket.read_buf >> 4
+        buf = socket.read_buf >> size
+        packet_name = self.unpack_str( buf )
+        buf.slice!( 0, packet_name.length + 1 )
+        
+        packet = const_get( packet_name.gsub( /\./, "::" ) ).new
+        packet.unpack( buf )
+      rescue => err
+        EaseEngine::Log.err( "#{packet_name}: #{err}" )
+        socket.err = err
+        socket.is_disable = true
+        packet = nil
+      end while false
+      
+      packet
+    end
+    
+    attr_reader :packet_name
+    
+    def initialize
+      @packers = []
+      @packet_name = self.class.name.gsub( /::/, "." )
+    end
+    
+    def packer( *args )
+      args.each{|name|
+        self.class.class_eval <<-EOS
+          def #{name}
+            @#{name}
+          end
+          
+          def #{name}=( value )
+            @#{name} = value
+          end
+        EOS
+        
+        @packers.push name
+      }
+    end
+    
+    def pack
+      bufs = []
+      bufs.push Packet.pack_str( @packet_name )
+      hash = {}
+      @packers.each{|name|
+        hash[ name.to_s ] = instance_variable_get( "@#{name}" )
+      }
+      bufs.push MessagePack.pack( hash )
+      bufs.join
+    end
+    
+    def unpack( buf )
+      MessagePack.unpack( buf ).each{|name, value|
+        instance_variable_set( "@#{name}", value ) if @packers.include?( name.to_sym )
+      }
+    end
+    
+    def write( socket, flags, *args )
+      packed_packet = pack
+      size = Packet.pack_uint32( packed_packet.size )
+      socket.send( "#{size}#{packed_packet}", flags, *args )
+    end
+  end
+  
+  class MeasurePacket < Packet
+    def initialize
+      super
+      
+      packer :sec, :usec
+      
+      start
+    end
+    
+    def start
+      time = ::Time.new
+      @sec = time.to_i
+      @usec = time.usec
+    end
+    
+    def check
+      EaseEngine::Time.new - ::Time.at( @sec, @usec )
+    end
+  end
+  
+  class HeartbeatBeginPacket < Packet
+  end
+  
+  class HeartbeatEndPacket < Packet
+  end
+end

data/lib/ease_engine/platform.rb

@@ -0,0 +1,19 @@
+module EaseEngine
+  class Platform
+    def self.ruby_platform
+      RUBY_PLATFORM.downcase
+    end
+    
+    def self.mac?
+      self.ruby_platform =~ /darwin/
+    end
+    
+    def self.linux?
+      self.ruby_platform =~ /linux/
+    end
+    
+    def self.windows?
+      self.ruby_platform =~ /mingw/
+    end
+  end
+end

data/lib/ease_engine/process.rb

@@ -0,0 +1,31 @@
+require "open3"
+
+module EaseEngine
+  class Process
+    def self.execute( cmd, option = {} )
+      out, err, status = Open3.capture3( cmd, option )
+      [ status.exitstatus, out, err ]
+    end
+    
+    def self.daemon( path, is_daemon, *args, &block )
+      pid_file_path = "#{path}.pid"
+      begin
+        if File.exist?( pid_file_path )
+          EaseEngine::Log.err "PID file exist: #{pid_file_path}"
+          break
+        end
+        
+        ::Process.daemon( *args ) if is_daemon
+        File.open( pid_file_path, "wb" ){|file|
+          file.puts "#{::Process.pid}"
+        }
+        log_file = File.open( "#{path}.log", "a+b" )
+        if ! log_file.nil?
+          block.call( log_file, pid_file_path )
+          log_file.close
+        end
+        File.delete pid_file_path if File.exist?( pid_file_path )
+      end while false
+    end
+  end
+end

data/lib/ease_engine/socket.rb

@@ -0,0 +1,174 @@
+require "ease_engine/buffer"
+require "socket"
+
+module EaseEngine
+  class Socket
+    attr_accessor   :socket, :read_buf, :write_buf, :err
+    attr_accessor   :read_max_size
+    attr_accessor   :dst_addr
+    attr_accessor   :is_disable
+    
+    def initialize( *args )
+      @read_buf = EaseEngine::Buffer.new
+      @write_buf = EaseEngine::Buffer.new
+      @err = nil
+      @read_max_size = 2048
+      @dst_addr = nil
+      @is_disable = false
+    end
+    
+    def bind( host, port )
+      @socket.bind( host, port )
+    end
+    
+    def send( msg, flags, *args )
+      @write_buf << msg
+      @err = nil
+      begin
+        result = @socket.send( @write_buf.value, flags, *args )
+      rescue => err
+        @err = err
+        result = 0
+      end
+      
+      @write_buf >> result
+      @is_disable = true if 0 == result
+      
+      result
+    end
+    
+    def recv( max, flags = 0 )
+      # 1回で全てのデータを読み込めるとは限らないので、複数回に分けてデータを全て読み込む
+      @err = nil
+      bufs = []
+      while true
+        begin
+          buf = @socket.recv_nonblock( max, flags )
+        rescue IO::EAGAINWaitReadable => err
+          buf = ""
+        rescue Errno::ECONNRESET => err
+          buf = ""
+        rescue => err
+          @err = err
+          buf = ""
+        end
+        break if buf.empty?
+        
+        bufs.push buf
+      end
+      
+      buf = bufs.join
+      @read_buf << buf
+      @is_disable = true if bufs.empty?
+      
+      buf
+    end
+    
+    def recvfrom( max, flags = 0 )
+      # 最大サイズが決まっているので、1回で読み込む
+      @err = nil
+      begin
+        result = @socket.recvfrom_nonblock( max, flags )
+      rescue => err
+        @err = err
+        result = [ "", nil ]
+      end
+      
+      @read_buf << result[ 0 ]
+      
+      result
+    end
+    
+    def close
+      if ! @socket.nil?
+        @socket.close
+        @socket = nil
+      end
+    end
+    
+    def to_i
+      @socket.to_i
+    end
+    
+    def errno
+      @socket.getsockopt( ::Socket::SOL_SOCKET, ::Socket::SO_ERROR ).unpack( "i" )[ 0 ]
+    end
+  end
+  
+  class TCPSocket < EaseEngine::Socket
+    attr_accessor   :is_heartbeat
+    attr_accessor   :is_timeout
+    
+    def initialize( *args )
+      super
+      
+      @is_heartbeat = false
+      @is_timeout = false
+      
+      case args.length
+      when 1
+        @socket = args[ 0 ]
+      when 2
+        @dst_addr = ::TCPSocket.gethostbyname( args[ 0 ] )
+        @dst_addr.push args[ 1 ]
+        @socket = ::Socket.new( @dst_addr[ 2 ], ::Socket::SOCK_STREAM, 0 )
+        connect
+      end
+    end
+    
+    def connect
+      @err = nil
+      begin
+        @socket.connect_nonblock( ::Socket.sockaddr_in( @dst_addr.last, @dst_addr[ 3 ] ) )
+      rescue => err
+        @err = err
+      end
+    end
+    
+    def recv( max, flags = 0 )
+      @is_timeout = false
+      super( max, flags )
+    end
+  end
+  
+  class TCPServer < EaseEngine::TCPSocket
+    def initialize( host, port )
+      super( ::TCPServer.new( host, port ) )
+    end
+    
+    def listen( backlog = Socket::Constants::SOMAXCONN )
+      @socket.listen( backlog )
+    end
+    
+    def accept
+      @err = nil
+      begin
+        EaseEngine::TCPSocket.new( @socket.accept )
+      rescue => err
+        @err = err
+        nil
+      end
+    end
+  end
+  
+  class UDPSocket < EaseEngine::Socket
+    def initialize( *args )
+      super
+      
+      @socket = ::UDPSocket.new
+    end
+    
+    def send( msg, flags, *args )
+      if args.empty? && ! @dst_addr.nil?
+        super( msg, flags, @dst_addr[ 3 ], @dst_addr[ 1 ] )
+      else
+        super( msg, flags, *args )
+      end
+    end
+    
+    def recv( max, flags = 0 )
+      buf, @dst_addr = recvfrom( max, flags )
+      buf
+    end
+  end
+end