vuf 1.0.1 → 1.1.0

data/lib/vuf.rb

@@ -1,3 +1,4 @@
+require "socket"
 require "thread"
 require "log4r"
 
@@ -7,6 +8,7 @@ require "vuf/working_pool"
 require "vuf/pool"
 require "vuf/batch"
 require "vuf/profiler"
+require "vuf/server"
 
 module Vuf
   # Your code goes here...

data/lib/vuf/profiler.rb

@@ -17,27 +17,33 @@ module Vuf
         @stats[:counter][label] += 1
       }
     end
-    def start(label)
-      @mutex.synchronize { @timers[[Thread.current,label]] = Time.new }
+    def start(label,limit=nil)
+      @mutex.synchronize { @timers[[Thread.current,label]] = [Time.new,limit] }
     end
     
     def stop(label)
+      Logger.error "Invalid label #{label}" unless label.instance_of?(String) || label.instance_of?(Symbol)
       new_time = Time.new
       @mutex.synchronize { 
-        time = @timers.delete([Thread.current,label])
+        time,limit = @timers.delete([Thread.current,label])
         if time
           @stats[:time][label] ||= []
-          @stats[:time][label] << new_time - time
+          t = new_time - time
+          if limit && t > limit
+            Logger.warn "Time limit exceeds for #{label} : #{t} s"
+          end
+          @stats[:time][label] << t
         end
       }
     end
     
     def result
-      counter_stat = [] ; time_stat = []
+      counter_stat = [] ; time_stat = [] ; current_time = Time.new
       error = nil
       @mutex.synchronize {
         begin 
-          @stats[:counter].each{|k,v| counter_stat << "#{k} => #{v.to_s.rjust(10,' ')}" }
+          @stats[:counter].each{|k,v| counter_stat << [k, "#{k} => #{v.to_s.rjust(10,' ')}"] }
+          counter_stat = counter_stat.sort{|a,b| a.first <=> b.first}.collect{|a| a.last}
           @stats[:time].each{ |k,v|
             # retrieve previous av_time and number of mesures (nbdata)
             av_time,nbdata = @stats[:avtime][k]
@@ -52,10 +58,17 @@ module Vuf
             end
             av_time = cumul_time / nbdata
             time_stat << "#{k.to_s.rjust(20,' ')} => #{av_time.round(8).to_s.rjust(12,' ')} s/op " + 
-            "[#{nbdata.to_s.rjust(12,' ')} op| #{(nbdata*av_time).round(2).to_s.rjust(8,' ')} s]"
+              "[#{nbdata.to_s.rjust(12,' ')} op| #{(nbdata*av_time).round(2).to_s.rjust(8,' ')} s]"
             @stats[:avtime][k] = [av_time,nbdata]
             @stats[:time][k] = nil
-          }      
+          }
+          @timers.each{|k,v|
+            t = current_time - v.first
+            if v.last && ( t > v.last)
+              time_stat << "Timeout on #{k.last} : #{t} s"
+            end
+          }
+          # time_stat = time_stat.sort{|a,b| a.first <=> b.first}.collect{|a| a.last}          
         rescue => e
           Logger.error {"Error in statistic #{e.message}\n#{e.backtrace.join("\n")}"}
           error = e

data/lib/vuf/server.rb

@@ -0,0 +1,85 @@
+module Vuf
+  class Server
+    
+    def initialize(port, session_klass)
+      @port = port
+      @sessions_ctx = {}
+      @server_thread = nil
+      @closing_q = Queue.new
+      @session_klass = session_klass
+      @wp = Vuf::WorkingPool.new(4)
+      @wp.run
+    end
+
+    def start
+      if @server_thread.nil?
+        @running = true
+        @server_thread = Thread.new do
+          Logger.debug "Server Starting"
+          begin
+            @server = TCPServer.new @port
+            @s_list = [@server]
+            while @running
+              close_ended_sessions
+              rsl, = IO.select(@s_list,[],[],1)
+              next if rsl.nil? # Timeout
+              accept(rsl) # Handle acceptance of new incoming session
+              rsl.each { |s| serve s }
+            end
+          rescue => e
+            Logger.error "Server Error [#{e}]
+              #{e.message}
+              #{e.backtrace.join("\n")}"
+          end
+        end
+      end
+    end
+    
+    def shutdown
+      @running = false
+      @server_thread.join unless @server_thread.nil?
+      @server_thread = nil
+    end    
+    
+    private
+    
+    def accept(selected)
+      serv = selected.delete(@server)
+      if serv
+        sock = serv.accept
+        @s_list << sock
+        @sessions_ctx[sock] = @session_klass.new(sock)
+      end
+    end
+    
+    def serve(sock)
+      msg_recv = sock.recv_nonblock(1024)
+      if msg_recv.empty?
+        @closing_q << sock
+      else
+        session = @sessions_ctx[sock]
+        @wp.do(session,session,msg_recv) do |sess,msg|
+          ret = sess.handle(msg)
+          if ret.nil?
+            Logger.error "Handle return nil on msg #{msg} at step #{sess.step}"
+          end
+        end
+      end
+    end
+    
+    def close_ended_sessions
+      until @closing_q.empty?
+        s = @closing_q.pop
+        session = @sessions_ctx.delete(s)
+         if session
+           @wp.do(session,session,s) do |sess,sock|
+             sess.finalize                
+             sock.close
+           end
+         end
+        @s_list.delete(s) 
+      end    
+    end
+  end
+end
+

data/lib/vuf/version.rb

@@ -1,3 +1,3 @@
 module Vuf
-  VERSION = "1.0.1"
+  VERSION = "1.1.0"
 end

data/lib/vuf/working_pool.rb

@@ -44,14 +44,19 @@ module Vuf
     
     def try_lock_channel(channel,task, args)
       new_channel_q = nil
+      error = nil
       @channels_mutex.synchronize {
         if @channels[channel].nil?
 	        new_channel_q = @channelsQ.shift
-          raise "Missing queue in working pool" unless new_channel_q.instance_of?(Queue)
           @channels[channel]=new_channel_q
 	      end
-        @channels[channel].push([task, args])
+        if @channels[channel].instance_of?(Queue)        
+          @channels[channel].push([task, args])
+        else
+          error = "Missing queue in working pool" 
+        end
       }
+      raise error unless error.nil?
       return new_channel_q
     end
     

data/test/lib/vuf/pool_test.rb

@@ -1,4 +1,19 @@
 require_relative '../../test_helper'
+class PoolKlass
+  include Vuf::Pool
+  attr_reader :i_index
+  def initialize
+    @@index ||= 0
+    @@index += 1
+    @i_index = @@index
+  end
+  
+  def write(msg)
+    @f = File.open(File.join("test", "tmp", "file_#{@i_index}.txt"),"w+")
+    @f.write(msg)
+    @f.close
+  end
+end
 
 describe Vuf::Pool do
   subject {  
@@ -23,34 +38,25 @@ describe Vuf::Pool do
   end
 end
 
+
 describe Vuf::Pool do
-  class PoolKlass
-    include Vuf::Pool
-    attr_reader :i_index
-    def initialize
-      @@index ||= 0
-      @@index += 1
-      @i_index = @@index
-      @f = File.open(File.join("test", "tmp", "file_#{@@index}.txt"),"w+")
-    end
-    
-    def write(msg)
-      @f.write(msg)
-    end
-  end
-    
 
   subject { 5 }
   
   it "must create 5 Files" do
     wp = Vuf::WorkingPool.new(subject)
     wp.run
-    1000.times do |i|
-      wp.do do 
-        poolklass_instance = PoolKlass.instance
-        poolklass_instance.write("Message #{i.to_s}\n")
-        PoolKlass.release
-      end
+    100.times do |i|
+      wp.do(i,i) { |i|
+        begin
+          writer = PoolKlass.instance
+          writer.write("Message #{i.to_s}\n")
+          sleep 0.01
+          PoolKlass.release
+        rescue => e
+          Vuf::Logger.error "#{e}\n#{e.message}\n#{e.backtrace.join("\n")}"
+        end
+      }
     end
     wp.finalize
     Dir[File.join("test", "tmp","file_*.txt")].size.must_equal(subject)

data/test/lib/vuf/profiler_test.rb

@@ -4,6 +4,7 @@ describe Vuf::Profiler do
   subject { Vuf::Profiler.new }
  
   it "must parse options without errors" do
+    Vuf::Logger.outputters = Log4r::FileOutputter.new("profile_logger", {:filename => "test/tmp/log_profiler.log"})
     subject.run(0.1)
     10000.times do 
       subject.start('test')
@@ -11,5 +12,6 @@ describe Vuf::Profiler do
       subject.stop('test')
     end
     subject.finalize
+    Vuf::Logger.outputters = Log4r::Outputter.stderr
   end
 end

data/test/lib/vuf/server_test.rb

@@ -0,0 +1,100 @@
+require_relative '../../test_helper'
+
+STEPS = ["IPDU_CN", "IPDU_AC", "MSG_804", "MSG_814", "MSG_306", "MSG_316", 
+  "MSG_246",  "MSG_256", "MSG_506",  "MSG_516", nil]
+
+ 
+class TestSession
+  attr_reader :step
+  def initialize(socket)
+    @sock = socket
+    @step = 0
+  end
+  
+  def start
+    @sock.send STEPS.first, 0
+    @step += 1
+  end
+  
+  def handle(msg)
+      curr_step = STEPS.index(msg)
+      if @step != curr_step
+        Vuf::Logger.error "Error received #{msg} on step #{@step}"
+        return nil
+      end      
+      @step += 1
+      reply = STEPS[@step]
+      return nil if reply.nil?
+      no_reply = true
+      begin
+        @sock.send reply,0    
+        no_reply = false
+      rescue => e
+        Vuf::Logger.error "Error on send #{reply} for  #{@sock} => [#{e}]
+            #{e.message}
+            #{e.backtrace.join("\n")}"        
+      ensure 
+        if no_reply
+          Vuf::Logger.error "No reply send on session #{@sock} for msg #{msg} / reply #{reply} on step #{@step}"
+        end
+      end
+      @step += 1
+      return @step
+  end
+  
+  def finalize
+    if @step != (STEPS.size - 1)
+      Vuf::Logger.error "Error finalize on step #{@step}"
+    end
+  end
+end
+
+
+class TestClient
+  def initialize(nb_req)
+    @nb_req = nb_req
+  end
+  
+  def run
+    sockets = []
+    sessions = {}
+    done = 0 ; done_mutex = Mutex.new
+    nb_run=0
+    until done == @nb_req
+      while sockets.size < 20 && nb_run < @nb_req
+        nb_run += 1
+        s =  TCPSocket.open('localhost',3527)
+        sockets << s
+        sessions[s] = TestSession.new(s)
+        sessions[s].start
+      end
+      
+      rsl, = IO.select(sockets,[],[],1)
+      
+      unless rsl.nil?
+        rsl.each do |s|
+          reply = s.recv(1024)
+          sess = sessions[s]
+          ret = sess.handle(reply)
+          if ret.nil?
+            s.close
+            done_mutex.synchronize { done += 1}
+            sockets.delete(s)
+            sessions.delete(s)
+          end
+        end
+      end
+    end
+  end
+end
+
+describe Vuf::Server do
+  subject { Vuf::Server.new(3527,TestSession) }
+ 
+  it "must parse options without errors" do
+    # Run the server with logging enabled (it's a separate thread).
+    subject.start
+    TestClient.new(100).run
+    subject.shutdown
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: vuf
 version: !ruby/object:Gem::Version
-  version: 1.0.1
+  version: 1.1.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-31 00:00:00.000000000 Z
+date: 2014-02-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -60,11 +60,13 @@ files:
 - lib/vuf/logger.rb
 - lib/vuf/pool.rb
 - lib/vuf/profiler.rb
+- lib/vuf/server.rb
 - lib/vuf/version.rb
 - lib/vuf/working_pool.rb
 - test/lib/vuf/batch_test.rb
 - test/lib/vuf/pool_test.rb
 - test/lib/vuf/profiler_test.rb
+- test/lib/vuf/server_test.rb
 - test/lib/vuf/wp_test.rb
 - test/test_helper.rb
 - test/tmp/.gitignore
@@ -99,6 +101,7 @@ test_files:
 - test/lib/vuf/batch_test.rb
 - test/lib/vuf/pool_test.rb
 - test/lib/vuf/profiler_test.rb
+- test/lib/vuf/server_test.rb
 - test/lib/vuf/wp_test.rb
 - test/test_helper.rb
 - test/tmp/.gitignore