minitcp 0.10.0 → 0.15.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 5a5ea8ac3aaaa06e3051b9d4e696713132b1e721
-  data.tar.gz: 98eb5966f3ff14ca68c1522110b6fdd3d941b3d3
+  metadata.gz: 40c86e0923a11e1d1399840594700ed14d087f5b
+  data.tar.gz: 25fc9a740519e40ed6ccf029cb986bb85e0e0a13
 SHA512:
-  metadata.gz: 87f235759fc78198cbeeb0446b788c685f4c82ca79947fe551f0822da7c29e5fb7961e756eec422b524d92d2821688871caeaee01ac502d831d093aa598288f5
-  data.tar.gz: d217d33d86b4181190730605dfe88ccbfc3405eeb022521ae8fab0b32041a4ed57d7a199c73fc34fa7bf0836c9e3a3cbb36e99aad413e1d65bf1a89b665e95bf
+  metadata.gz: 1e59ae815447e1bd2639a3a49a8c536f9af7856c88a6c0861e643e671f78f68973eeec0ecb1cc1c067c6730e88d1bd3ee61b9633d7844550f4c09fcdee72d445
+  data.tar.gz: b204d6cb22237371a6bb93e449ee977564d7e8d9931ed86b0d1c76b15c1b310f726611f8f7168a6627f7a834fde673f6366361cdd933358ed6c3f433a0f962c5

data/CHANGELOG.txt

@@ -1,3 +1,23 @@
+0.15.0 : 2015-04-02 15:51:14 +0200
+    minitcp.rb : force data received to encding BINARY
+0.14.0 : 2015-01-13 20:56:17 +0100
+    minitcp.rb : no audit, no log for tcp server
+    relaiproxy.rb : notraces
+    relai_config.data : test1 aded
+    minitcp.rb : no traces
+0.13.0 : 2014-11-28 13:35:33 +0100
+    plot.rb : window resize enable
+    pingpongplot.rb : multiple url test
+    README.md : message agent expample
+    README.md : massage agent expalple
+    README.md : example message
+    README.md : example for agent message
+0.12.0 : 2014-10-30 21:31:33 +0100
+0.11.0 : 2014-10-30 21:30:28 +0100
+    README.md : ocpp
+    README.md : plugin doc
+    Rakefile.rb : version management
+    README.md : plugin ocpp description
 0.10.0 : 2014-09-24 20:18:54 +0200
     minitcp.rb : reveive_n_byte correction
 0.9.0 : 2014-09-18 22:38:31 +0200

data/README.md

@@ -61,6 +61,28 @@ A UDP sender :
 	)
 ```
 
+A Message agent :
+Message Client:
+```ruby
+MClientAgent.run("localhost",2222) do |chan|
+  chan.send_message({date: Time.now.to_f}) 
+  chan.on_message do |mess| 
+	puts "cli: receive: #{mess.inspect}" 
+	chan.close
+	nil
+  end
+  chan.on_timeout(10_000) { p "timeout" ; chan.close rescue nil }
+  chan.wait_end
+end
+```
+
+Message Server:
+```ruby
+MServerAgent.run(2222,"localhost",22) do |chan|
+    chan.on_message { |mess|  p mess ; "ok" }
+    chan.wait_end
+end
+```
 
 Docs: http://rubydoc.info/gems/minitcp
 
@@ -126,13 +148,27 @@ UDP
 * **send_datagram(host,port,message)** : create a socket, send mesage and close socket (ca'nt receive a reply)
 * **send_datagram_on_socket(socket,host,port,message)** : use existant socket for send a message to ip:port
 
+Messages
+===
+Serveur and client ```MServerAgent``` and ```MClientAgent``` define a 'agent ' which
+can communicate by messages.
+
+Messages are ```ruby-data.inspect```, max size is 1 MByte.
+* MClientAgent.run(host,port) : connect to a MServerAgent, for communicate by message
+* MServerAgent.run(port,host,max-connections) : message server
+
+in Agent, socket are extended with this capability :
+* socket.send_message(data)
+* socket.on_message { |data|  .... ; ret_data}  will send ret_data to sender if not nil
+
+See test.rb for an example
 
 TODO
 ==
 
 * Serial line
 * more socket primitive
-
+* messages Agent : use Marchal instead of inspect/eval ....
 
 Tests case
 ==

data/VERSION

@@ -1 +1 @@
-0.10.0
+0.15.0

data/lib/minitcp.rb

@@ -11,9 +11,9 @@ require 'gserver'
 
 
 module SocketReactive
-
+  def strempty() ''.force_encoding Encoding::BINARY end
   def data_readed=(v) @data_readed=v end
-  def data_readed()   @data_readed||="" end
+  def data_readed()   @data_readed||=strempty end
 
   # read n byte, block the caller, return nil if socket if close
   # if block is defined, it is yield with data, method return whith the value of yield
@@ -29,7 +29,7 @@ module SocketReactive
     loop do
       #p ["waiting ",s,data_readed]
       sd=s>1024 ? 1024 : s
-      data=(self.recv(sd) rescue nil)
+      data=(self.recv(sd) rescue (p $!;nil))
       #p "nrec: w#{sizemax}/ rec:#{(data||'').size} / #{sd} old=#{data_readed.size} /// #{(data||'').size<70 ? data : "."}"
       if data && data.size>0
         self.data_readed=self.data_readed+data
@@ -75,7 +75,7 @@ module SocketReactive
     Thread.new() do
       begin
         if self.data_readed.size>0
-          buff,self.data_readed=self.data_readed,""
+          buff,self.data_readed=self.data_readed,strempty
           yield(buff)
         end
         loop do
@@ -317,16 +317,16 @@ end
 # Run a TCP serveur, with a max connection simultaneous,
 # When connection succes, call the bloc given with socket (extended by SocketReactive).
 #
-# MServer( "8080" , "0.0.0.0" ,1) { |socket| loop { p socket.gets} }
+# MServer.new( "8080" , "0.0.0.0" ,1) { |socket| loop { p socket.gets} }
 class MServer < GServer
   def self.service(port,host,max,&b)
     srv=new(port,host,max,&b)
-    srv.audit = true
+    srv.audit = false
     srv.start
     srv
   end
   def initialize(port,host,max=1,&b)
-    super(port,host,max)
+    super(port,host,max,nil)
     @bloc=b
   end
   def serve( io )
@@ -339,3 +339,43 @@ class MServer < GServer
   end
 end
 
+##########################################################
+# messages stream
+##########################################################
+
+module SocketMessage
+	def on_message(timeout=nil,&b)
+		on_n_receive(6) do |head| 
+			len=head.to_i
+			received_n_timeout(len,10_000) do |data|
+				response=b.call(eval(data))
+				send(response) if response
+			end
+	  end
+  end
+	def send_message(message)
+		data=message.inspect
+		send(("%6d" % data.size)+data,0)		
+	end
+end
+
+class MClientAgent
+  def self.run(host,port,&b) 
+    me=MClientAgent.new
+	  MClient.run_continious(host,port,10_000) do |so|
+      so.extend(SocketMessage)
+      me.instance_eval { b.call(so) }
+	  end
+  end
+end
+
+class MServerAgent
+ def self.run(port,host,n,&b)
+   me=MClientAgent.new
+   MServer.service( port , host ,n) do |so|
+		so.extend(SocketMessage)
+		me.instance_eval { b.call(so) }		
+   end
+ end
+end
+

data/samples/pxy.rb

@@ -0,0 +1,429 @@
+#!/usr/bin/ruby
+# LGPL
+####################################################
+# proxy.rb : pure tcp proxy, for dev/admin/fun :)
+#
+# Usage :
+#   > ruby proxy.rb target-hostname target-port [mode]
+#       mode= ascii/bin/none : style of printing
+####################################################
+# LGPL,  Author: Regis d'Aubarede <regis.aubarede@gmail.com>
+#
+##################################################### start minitcp
+
+##############################################################
+# minitcp.rb
+##############################################################
+
+require 'thread'
+require 'timeout'
+require 'socket'
+require 'gserver'
+
+
+module SocketReactive
+
+  def data_readed=(v) @data_readed=v end
+  def data_readed()   @data_readed||="" end
+
+  # read n byte, block the caller, return nil if socket if close
+  # if block is defined, it is yield with data, method return whith the value of yield
+  # if looping is true, the method loop until socket close, (or current thread is killed)
+  def receive_n_bytes(sizemax,looping=false,&b)
+    s=sizemax
+    if self.data_readed.size>=sizemax
+      buff,self.data_readed=self.data_readed[0..sizemax-1],self.data_readed[sizemax..-1]
+      buff=b.call(buff) if block_given?
+      return buff unless looping
+    end
+    s=sizemax-self.data_readed.size
+    loop do
+      #p ["waiting ",s,data_readed]
+      sd=s>1024 ? 1024 : s
+      data=(self.recv(sd) rescue (p $!;nil))
+      #p "nrec: w#{sizemax}/ rec:#{(data||'').size} / #{sd} old=#{data_readed.size} /// #{(data||'').size<70 ? data : "."}"
+      if data && data.size>0
+        self.data_readed=self.data_readed+data
+        s=sizemax-self.data_readed.size
+        if s<=0
+          buff,self.data_readed=self.data_readed,""
+          s=sizemax
+          buff=b.call(buff) if block_given?
+          return buff unless looping
+        end
+      else
+        close rescue nil
+        break # socket close
+      end
+    end #loop
+  end
+  # wait n byte or timeout. if block is defined, it is yielded with data
+  # return nil if timeout/socket closed, or data if no bloc, or yield value
+  def received_n_timeout(sizemax,timeout_ms,&b)
+    timeout(timeout_ms/1000.0) {
+      ret=receive_n_bytes(sizemax,false,&b)
+      return ret
+    }
+  rescue Timeout::Error
+    return nil
+  rescue Exception => e
+    $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+  end
+  
+  def received_any_timeout(sizemax,timeout_ms)
+    timeout(timeout_ms/1000.0) {
+      return recv(sizemax)
+    }
+  rescue Timeout::Error
+    return nil
+  rescue Exception => e
+    $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+  end
+
+  # async wait and read data on socket, yield values readed,
+  # return thread spawned, which can be kill
+  def on_any_receive()
+    Thread.new() do
+      begin
+        if self.data_readed.size>0
+          buff,self.data_readed=self.data_readed,""
+          yield(buff)
+        end
+        loop do
+          data=(self.recv(64*1024) rescue nil)
+          data && data.size>0 ? yield(data) : break
+        end
+      rescue Exception => e
+        $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+      end
+      close rescue nil
+    end
+  end
+
+
+  # async yield on received n bytes
+  # return thread spawned, which can be kill
+  def on_n_receive(sizemax=1,&b)
+    Thread.new() do
+      begin
+        receive_n_bytes(sizemax,true,&b)
+      rescue Exception => e
+        $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+      end
+    end
+  end
+
+  # read until separator reached, block the caller, return nil if socket is close
+  # if block is defined, it is yield with data, method return whith the value of yield
+  # if looping is true, the method loop until socket close, (or current thread is killed)
+  # this read some extra data. they can be retrieve with in socket.data_readed.
+  # data_readed is use for next calls to receives_n_byte/receive_sep
+  def receive_sep(separator,sizemax=1024,looping=false,&b)
+    if self.data_readed.size>0
+      a=self.data_readed.split(separator,2)
+      while a.size>1
+        buff= a.size>2 ? a[0..-2] : a.first
+        self.data_readed=a.last
+        buff=b.call(buff) if block_given?
+        return buff unless looping
+        a=self.data_readed.split(separator,2)
+      end
+    end
+    loop do
+      data=(self.recv(sizemax-self.data_readed.size) rescue nil)
+      if data && data.size>0
+        self.data_readed=self.data_readed+data
+        a=(self.data_readed).split(separator,2)
+        while a.size>1
+          buff= a.size>2 ? a[0..-2] : a.first
+          self.data_readed=a.last
+          buff=b.call(buff) if block_given?
+          return buff unless looping
+          a=(self.data_readed).split(separator,2)
+        end
+      else
+        close rescue nil
+        break
+      end
+    end
+  end
+
+  # async yield on received data until end-buffer string
+  # end-buffer can be string or regexp (args of data.split(,2))
+  # return thread spawned, which can be kill
+  # this read some extra data. they can be retrieve with in socket.data_readed.
+  # data_readed is use for next calls to receives_n_byte/receive_sep
+  def on_receive_sep(separator,sizemax=1024,&b)
+    Thread.new() do
+      begin
+        receive_sep(separator,sizemax,looping=true,&b)
+      rescue Exception => e
+        $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+      end
+    end
+  end
+
+  # async yield after a duration, if socket is open
+  # return thread spawned, which can be kill
+  def after(duration_ms)
+    Thread.new() do
+      begin
+        sleep(duration_ms/1000.0)
+        yield unless self.connected?()
+      rescue Exception => e
+        $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+      end
+    end
+  end
+
+  # async yield periodicaly, if socket is open
+  # return thread spawned, which can be kill
+  def on_timer(value=1000)
+    Thread.new() {
+      begin
+        nbtick=(value/TICK)+1
+        loop do
+          i=0
+          sleep(TICK/1000.0) while self.connected?() && (i+=1)<nbtick
+          self.connected?() ? yield() : break
+        end
+      rescue Exception => e
+        $stdout.puts  "#{e} :\n  #{e.backtrace.join("\n  ")}"
+      end
+    }
+  end
+
+  # wait until curent socket is close.
+  def wait_end()
+    begin
+      loop do
+        sleep(TICK/1000.0) while (self.connected?() rescue nil)
+        break
+      end
+    rescue Exception => e
+    end
+  end
+
+  # Test if a socket is open. (use socket.remote_address() !)
+  def connected?()
+    (self.remote_address rescue nil) ? true : false
+  end
+  # duration of sleep when active wait (wait_end,on_timer...)
+  TICK=600
+
+  def self.make_socket_reactive(socket)
+    socket.extend(SocketReactive)
+    socket.data_readed=""
+  end
+end
+
+# Assure connection to server, extend socket connection by SocketReactive module.
+#
+#	MClient.run_one_shot("localhost",2200)       do |socket| .. end.join
+#
+#	MClient.run_continous("localhost",2200,6000) do |socket| .. end.join
+#
+class MClient
+  # maintain a conntection to a TCP serveur, sleep timer_interconnection_ms millisecondes
+  # beetwen each reconnections 
+  def self.run_continious(host,port,timer_interconnection_ms,&b)
+    Thread.new do
+      loop { run_one_shot(host,port,&b).join ; sleep timer_interconnection_ms/1000.0 }
+    end
+  end
+
+  def self.run_continous(host,port,timer_interconnection,&b)
+    self.run_continious(host,port,timer_interconnection,&b)
+  end
+
+  # Connecte to a TCP server, call block with client socket if connection sucess.
+  # enssure close connection after end of block
+  def self.run_one_shot(host="localhost",port=80)
+    begin
+      sleep(0.03) # give some time for server ready (for test...)
+      socket = TCPSocket.new(host,port)
+    rescue
+      puts "not connected to #{host}:#{port}: " + $!.to_s
+      return (Thread.new {})
+    end
+    SocketReactive::make_socket_reactive(socket)
+    Thread.new do
+      begin
+        yield(socket)
+      rescue Exception => e
+        puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+      ensure
+        socket.close() rescue nil
+      end
+    end
+  end
+end
+
+
+# Assure connection to server, extend socket connection by SocketReactive module.
+#
+#	MClient.run_one_shot("localhost",2200)       do |socket| .. end.join
+#
+#	MClient.run_continous("localhost",2200,6000) do |socket| .. end.join
+#
+class UDPAgent
+  # maintain a conntection to a TCP serveur, sleep timer_interconnection_ms millisecondes
+  # beetwen each reconnections 
+  def self.send_datagram(host,port,mess)
+        sock = UDPSocket.new
+        #p ["sock.send",mess, 0, host, port]
+        sock.send(mess, 0, host, port)
+        sock.close
+  end
+  def self.send_datagram_on_socket(socket,host,port,mess)
+        socket.send(mess, 0, host, port)
+  end
+
+  Thread.abort_on_exception=true
+
+  # send datagram on timer
+  def self.on_timer(periode,options)
+    Thread.new do 
+      sleep periode/1000.0
+      sock = UDPSocket.new
+      if options[:port]
+        sock.bind("0.0.0.0", options[:port])
+      end
+      loop do
+        rep=IO.select([sock],nil,nil,periode/1000.0)
+        #puts  "IO.SELECT => #{rep}"
+        if rep
+          Thread.new {
+               data,peer=sock.recvfrom(1024)
+               options[:on_receive].call(data,peer,sock)
+          } if options[:on_receive]
+        elsif options[:on_timer]
+          h=options[:on_timer].call()
+          self.send_datagram_on_socket(sock,h[:host], h[:port],h[:mess]) if h && h[:mess] && h[:host] && h[:port]
+        end
+      end
+    end
+  end
+  # recieved UDP datagramme, bloc can ellaborate a reply, which will be sending to client
+  def self.on_datagramme(host,port)
+    serv = UDPSocket.new
+    serv.bind(host, port)
+    Thread.new do
+      loop do
+        begin
+        Thread.new(*serv.recvfrom(1024)) do |data,peer|  # peer=["AF_INET", 59340, "127.0.0.1", "127.0.0.1"]
+            proto,cli_port,srv_addr,cli_addr=*peer
+            response=yield(data,cli_addr,cli_port)
+            self.send_datagram_on_socket(serv,cli_addr,cli_port,response) if response
+        end
+        rescue Exception => e
+          puts "#{e}\n  #{e.backtrace.join("\n  ")}"
+        ensure
+        end
+      end
+    end
+  end
+end
+
+# Run a TCP serveur, with a max connection simultaneous,
+# When connection succes, call the bloc given with socket (extended by SocketReactive).
+#
+# MServer.new( "8080" , "0.0.0.0" ,1) { |socket| loop { p socket.gets} }
+class MServer < GServer
+  def self.service(port,host,max,&b)
+    srv=new(port,host,max,&b)
+    srv.audit = true
+    srv.start
+    srv
+  end
+  def initialize(port,host,max=1,&b)
+    super(port,host,max)
+    @bloc=b
+  end
+  def serve( io )
+    SocketReactive::make_socket_reactive(io)
+    begin
+      @bloc.call(io)
+    rescue Exception => e
+      puts  "Error in Mserver block: #{e} :\n  #{e.backtrace.join("\n  ")}"
+    end
+  end
+end
+
+##########################################################
+# messages stream
+##########################################################
+
+module SocketMessage
+	def on_message(timeout=nil,&b)
+		on_n_receive(6) do |head| 
+			len=head.to_i
+			received_n_timeout(len,10_000) do |data|
+				response=b.call(eval(data))
+				send(response) if response
+			end
+	  end
+  end
+	def send_message(message)
+		data=message.inspect
+		send(("%6d" % data.size)+data,0)		
+	end
+end
+
+class MClientAgent
+  def self.run(host,port,&b) 
+    me=MClientAgent.new
+	  MClient.run_continious(host,port,10_000) do |so|
+      so.extend(SocketMessage)
+      me.instance_eval { b.call(so) }
+	  end
+  end
+end
+
+class MServerAgent
+ def self.run(port,host,n,&b)
+   me=MClientAgent.new
+   MServer.service( port , host ,n) do |so|
+		so.extend(SocketMessage)
+		me.instance_eval { b.call(so) }		
+   end
+ end
+end
+
+##################################################### end minitcp
+
+$host,$port,$opt=ARGV[0]||"localhost",ARGV[1]||80,ARGV[2]||"ascii"
+puts "Server on port 2200, proxy to #{$host}:#{$port}..."
+
+
+MServer.service(2200,"0.0.0.0",22) do |s_cli|
+  puts "> ======== client Connected ========"
+  srv=MClient.run_one_shot($host,$port) do |s_srv|
+     puts "< ======== server Concected ========"
+     s_srv.on_any_receive { |data| spy 1,data; s_cli.print data }
+     s_cli.on_any_receive { |data| spy 2,data; s_srv.print data}
+     s_srv.wait_end
+     s_cli.close rescue nil
+  end
+  s_cli.wait_end
+  p "end cli, stop proxy"
+  srv.kill
+end
+
+def spy(sens,data)
+  return if $opt=="none"
+  prefix=(sens==1 ? "< " : "> ")
+  if $opt=="ascii"
+    data.each_line {|line| puts "#{prefix}#{line.chomp}"  }
+  else
+    data.chars.each_slice(16) do |aline|
+      a=(aline.map { |char| "%02X " % char.ord }).join.ljust(16*3)+prefix+
+         aline.map { |char| (char.ord>30 ? char : "~") }.join()
+      puts "#{prefix}#{a}"
+    end
+  end
+end
+
+sleep
+
+

data/samples/relay/README.md

@@ -26,16 +26,39 @@ Server ---------------> |  proxy-relai  | <------//--------| relai | -----------
            internet server                              server-in-intranet         intranet hosts
 ```
 
+Plugin
+======
+
+Relai receive http request for an intranet server. 
+Plugin must be writing for find ip:port/path  for the host target.
+this can varying with http-subprotocole used.
+
+occp plugin is the first plugin used :
+* requests servied by this plugin are SOAP, header contain a field  ```<ChargeBoxId>name-equipment</ChargeBoxId>```
+* a local config file give url for each id
+* the plugin will :
+1) parse the request for finding the value of ChargeBoxId (regexp)
+2) find ip:port/path for the itranet-server adressed
+3) modify the path in the GET http command
 
 Usage
 =====
 Extranet:
+
+```
     >  ruby relaiproxy.rb  proxyhttp  proxy-hostname proxy-port
+```
 
 Intranet:
+
+```
     > vi relai_config.rb
+```
+    
+```
     >  ruby relaiproxy.rb  relai      proxy-ip  proxy-port  plugin-name
+```
 
-(actualy ocpp is the plugin)
+(actualy 'ocpp' is only plugin disponible)
 
 

data/samples/relay/relai_config.data

@@ -1,4 +1,5 @@
 {
+"TEST1" => ["localhost",7780,""],
 "TOTO" => ["localhost",7708,""],
 "TITI" => ["localhost",80,"/"]
-} 
+}  

data/samples/relay/relaiproxy.rb

@@ -27,67 +27,106 @@ Server ---------------> |  proxy-relai  | <------//--------| relai | -----------
            internet server                              server-in-intranet         intranet hosts
 =end
 
-#require 'minitcp'
-require_relative 'minitcp/lib/minitcp.rb'
+require 'minitcp'
+#require_relative 'minitcp/lib/minitcp.rb'
 
 if ARGV.size<1
   puts"Usage>"
-  puts"  #{$0} type hostname port"
+  puts"  #{$0} type       hostname       port"
   puts"  #{$0} proxyhttp  proxy-hostname proxy-port"
-  puts"  #{$0} relai      proxy-saia-ip  proxy-saia-port  plugin"
+  puts"  #{$0} relai      proxy-saia-ip  proxy-port  plugin"
   exit(1)
 end
 
 $opt,$host,$port=ARGV[0]||"proxyhttp",ARGV[1]||"localhost",ARGV[2]||80
 
 NBDIGITHEAD=8
-QUEUE_SIZE=100
+QUEUE_SIZE=10
 
 def sformat(socket,mess) 
-  socket.send("%-#{NBDIGITHEAD}d%s" % [mess.size,mess],0)
+  puts "sformat message len=#{mess.size} #{mess.inspect[0..30]}..."
+  data=("%-#{NBDIGITHEAD}d%s" % [mess.size,mess])
+  socket.send(data,0)
+end
+
+def sformat0(socket,mess) 
+  data=("%-#{NBDIGITHEAD}d%s" % [mess.size,mess])
+  l=socket.send(data,0)
 end
 def receive(socket) 
-        resp_length= socket.receive_n_bytes(NBDIGITHEAD)
-        len   =resp_length.strip.to_i
-        #log "header: #{resp_length} => #{len}"
-        (len>0) ? socket.receive_n_bytes(len) : ""
+  log "r1 len=#{NBDIGITHEAD} #{socket}"
+  resp_length= socket.receive_n_bytes(NBDIGITHEAD)
+  return nil unless resp_length
+  len   =resp_length.strip.to_i
+  log "header: #{resp_length} => #{len}"
+  (len>0) ? socket.receive_n_bytes(len) : ""
+end
+def receive_to(socket,to=1000) 
+  begin
+    timeout(to/1000.0) {
+      #log "r1 len=#{NBDIGITHEAD} #{socket}"
+      resp_length= socket.receive_n_bytes(NBDIGITHEAD)
+      return nil unless resp_length
+      len   =resp_length.strip.to_i
+      #log "header: #{resp_length} => #{len}"
+      (len>0) ? socket.receive_n_bytes(len) : ""
+    } 
+  rescue Exception => e
+    return(nil)
+  end
 end
 def log(t) puts "%10s | %s" % [Time.now.to_s,t] end
 
 if $opt=="proxyhttp"
 ##################################################################################
-##                              P R O X Y
+##                              P R O X Y : extranet side
 ##################################################################################
 
 $client_sockets ={} 
 $queue=Queue.new
 ############# Proxy serveur http saia >>> machine distante #######################
-
-MServer.service($port.to_i,"0.0.0.0",22) do |s_cli|
-  
-  begin relai=$queue.pop end until $client_sockets[relai]
+def relai_command(mess)
+  relai=nil
   begin
-    header=s_cli.receive_sep("\r\n\r\n")
-    log("request...#{header.inspect}")
-    if header.match(/^Content-length: (\d+)/i) || "0"=~/(.)/
-      length=$1.strip.to_i
-      log("length body==#{length}")
-      body= length>0 ? s_cli.receive_n_bytes(length) : ""
-      mess="#{header}\r\n\r\n#{body}"
-      log("transmit request...")
-        sformat(relai,mess) 
-        log("wait response...")
-        response= (timeout(5) { receive(relai) } rescue nil)
-      log(response!=nil ? "response ok" : "timeout") unless response
-      s_cli.write(response ? response : "HTTP/1.0 500 NOK\r\n\r\n")
-    else
-      s_cli.write( "HTTP/1.0 501 NOK\r\n\r\n")
-    end
+    loop  {
+      begin relai=$queue.pop end until $client_sockets[relai]
+      sformat(relai,"SDV")
+      break if receive_to(relai,1000)!=nil
+    }
+    log("getted relai #{relai}")
+    sformat(relai,mess) 
+    log("wait response...")
+    receive_to(relai,9000)
   ensure
-    $queue.push(relai)
+    $queue.push(relai) if relai
   end
 end
 
+MServer.service($port.to_i,"0.0.0.0",22) do |s_cli|
+  log("telecommande")
+  timeout(10) {
+    begin
+      header=s_cli.receive_sep("\r\n\r\n")
+      #log("request header=#{header.inspect}")
+      if header.match(/^Content-Length: (\d+)/i) || "0"=~/(.)/
+        length=$1.strip.to_i
+        #log("length body==#{length}")
+        body= length>0 ? s_cli.receive_n_bytes(length) : ""
+        #log("request body=#{body.inspect}")
+        mess="#{header}\r\n\r\n#{body}"
+        log("transmit request...")
+        response=relai_command(mess)
+        log(response!=nil ? "response ok" : "timeout") unless response
+        s_cli.write(response ? response : "HTTP/1.0 500 NOK\r\n\r\n")
+      else
+        s_cli.write( "HTTP/1.0 501 NOK\r\n\r\n")
+      end
+    rescue Exception => e
+     puts "global error: #{e} #{}"
+    end
+  }
+end
+
 ############# serveur http  machine distante #######################
 
 MServer.service($port.to_i+1,"0.0.0.0",22) do |s_cli|
@@ -99,17 +138,48 @@ MServer.service($port.to_i+1,"0.0.0.0",22) do |s_cli|
   $client_sockets.delete(s_cli)
 end
 
+#-- signe de vie sur chaque socket du pool
+
+Thread.new { loop {
+  begin relai=$queue.pop end until $client_sockets[relai]
+  #puts "testing #{relai}..."
+  sformat0(relai,"SDV")
+  receive_to(relai,1000)
+  sleep(0.1)
+  if $client_sockets[relai]
+    $queue.push(relai)
+    sleep 5
+  else
+    puts "testing socket pool:  nok"
+  end
+} }
 else
 
 ##################################################################################
-##                              R E L A Y
+##                              R E L A Y : intranet side
 ##################################################################################
 CONF="relai_config.data"
-plugin=ARGV.last||"ocpp"
-p plugin
+$plugin=ARGV.last||"ocpp"
 $config=nil
 $configtime=nil
-
+=begin
+<soap:Envelope xmlns:soap="http://www.w3.org/2003/05/soap-envelope">
+  <soap:Header>
+    <chargeBoxIdentity xmlns="urn://Ocpp/Cp/2012/06/">TEST1</chargeBoxIdentity>
+    <Action xmlns="http://www.w3.org/2005/08/addressing">/ChangeAvailability</Action>
+    <MessageID xmlns="http://www.w3.org/2005/08/addressing">urn:uuid:4efc4b17-6fc0-4a91-bf0b-153ecbc03cd0</MessageID>
+    <To xmlns="http://www.w3.org/2005/08/addressing">http://localhost:7700/</To>
+    <ReplyTo xmlns="http://www.w3.org/2005/08/addressing">
+       <Address>http://www.w3.org/2005/08/addressing/anonymous</Address>
+    </ReplyTo>
+  </soap:Header>
+  <soap:Body><changeAvailabilityRequest xmlns="urn://Ocpp/Cp/2012/06/">
+    <connectorId>1</connectorId>
+    <type>Operative</type>
+    </changeAvailabilityRequest>
+  </soap:Body>
+</soap:Envelope>
+=end
 def load_config()
   return if  $configtime!=nil && $configtime.to_f == File.mtime(CONF).to_f
   begin
@@ -121,58 +191,87 @@ def load_config()
     log("Error loading configration : #{$!}")
   end
 end
-
+def verify_request_ocpp(request)
+  (log("request does not contain ChargeBoxId0");return false) unless request =~/chargeBoxIdentity/i
+  return(true)
+end
 def transform_ocpp(request)
   load_config
-  pos=0
-  puts "recieved request #{request}"
-  (log("request does not contain ChargeBoxId");return nil) unless pos=(request =~/ChargeBoxId/i) 
-  (log("request does not contain ChargeBoxId");return nil) unless request[pos,pos+50] =~ /%3E(.*?)%3C/m 
-  id=$1.strip
-  ip=$config[id]
-  (log("unknown CS #{id} in config"); return nil) unless ip
-  request.sub!(/\?[^\s]*/,"")
-  request.sub!(/GET [^\s]*/,"GET #{ip.last}") if ip.last!=""
-  [*ip,request]
+  (log("request does not contain valid ChargeBoxId");return nil) unless request =~ /chargeBoxIdentity.*?>(.*?)<\/.*?chargeBoxIdentity/
+  chargeboxIdentity=$1.strip
+  ip=$config[chargeboxIdentity] # [ip,port,path]
+  unless ip
+    p request
+    log("unknown CS #{chargeboxIdentity} in config")
+    nil
+  else
+    #request.gsub!(
+    #   %r{(<To[^>]*>http://)([^<]*)(</To>)},
+    #   "\\1#{ip[0]}:#{ip[1]}#{ip[2]}\\3"
+    #)
+    #puts request
+    ip+[request] # return [ip, port, path, request]
+  end
 end
 
 def transmit(ip,port=nil,path=nil,request=nil) 
-  return "HTTP/1.0 404 NOK\r\n\r\n" unless request
-  log("send data <#{request.inspect[0..70]}...\n    > to #{ip}:#{port}#{path} len=#{request.size}")
+  return "HTTP/1.0 404 NOK\r\n\r\n"  unless request
+  
+  #log("send data <#{request.inspect[0..70]}...\n    > to #{ip}:#{port}#{path} len=#{request.size}")
   response=nil
-  MClient.run_one_shot(ip,port) { |socket| 
-    socket.send(request,0)
-    header=socket.receive_sep("\r\n\r\n")
-    puts header
-    response=header+"\r\n\r\n"+if header=~/Content-length: (\d+)/i && $1 && $1.to_i>0
-      puts "with content-length #{$1}"
-      socket.received_n_timeout($1.to_i,10) rescue "ERROR"
-    else
-      puts "until close"
-      rep=""
-      rep+=(a=socket.receive_any(1000_000)) until a==nil
-      rep
+  begin
+    timeout(5) do
+      MClient.run_one_shot(ip,port) { |client| 
+        client.send(request,0)
+        header=client.receive_sep("\r\n\r\n")
+        if header=~/Content-Length: (\d+)/i  && $1.to_i>0
+          log( "receive data with content-length #{$1}")
+          begin
+            data_response=client.received_timeout($1.to_i,3000) 
+          rescue
+            log($!.to_s)
+            data_response="ERROR_TIMEOUT"
+          end
+        else
+          puts "until close"
+          rep=""
+          rep+=(a=client.receive_any(1000_000)) until a==nil
+          data_response=rep
+        end
+        #log( "data_response="+data_response)
+        response=header+"\r\n\r\n" + data_response
+      }.join
+      response
     end
-  }.join
-  response
+  rescue Exception => e
+    p e
+    nil
+  end
 end
 
 QUEUE_SIZE.times do
   MClient.run_continious($host,$port.to_i+1,1000) do |socket|
     nbr=0
+    puts "connected..."
     socket.on_n_receive(NBDIGITHEAD) do |header|
-      p header
+      #p header
       nbr+=1
       len=header.strip.to_i
       #p len
       request=socket.receive_n_bytes(len)
       #p request
-      response= transmit(*send("transform_#{plugin}",request))
-      puts "replay with len=#{(response||"").size} <<<\n#{(response.inspect||"")[0..40]}..#{(response.inspect||"")[-40..-1]}\n>>"
-      sformat( socket, response ? response : "NOK #{Time.now}")  
-      (socket.close rescue nil) if nbr>100
+      if request!="SDV" && send("verify_request_#{$plugin}",request)
+        ip,port,path,request=send("transform_#{$plugin}",request)
+        response= transmit(ip,port,path,request)
+        puts "\n\nreplay with len=#{(response||"").size} <<<\n#{(response.inspect||"")[0..150]}..#{(response.inspect||"")[-40..-1]}\n>>"
+        sformat( socket, response ? response : "NOK #{Time.now}\r\n")
+      else 
+        sformat(socket,"OK")
+        print "."
+      end
     end
     socket.wait_end
+    puts "deconnected."
   end
 end
 

data/test.rb

@@ -42,7 +42,7 @@ if  ARGV.size==0 || ARGV[0]=="2"
       (socket.close; next) if s!="e"
       size=data.to_i
       puts "     Server waiting for #{size} Bytes of data"
-      socket.received_timeout(size,100_000) do |data|
+      socket.received_n_timeout(size,100_000) do |data|
        puts "     Server recieved buffer : #{data.size} Bytes"
        puts "     emit ack..."
        socket.send("o",0) 
@@ -61,7 +61,7 @@ if  ARGV.size==0 || ARGV[0]=="2"
        s,data=data[0..(1024-1)],data[1024..-1]
        socket.send s,0
      end 
-     p socket.received_timeout(1,[size/1000,1000].max)  ? "ack ok" : "!!! timeout ack"
+     p socket.received_n_timeout(1,[size/1000,1000].max)  ? "ack ok" : "!!! timeout ack"
      #puts "\n"*7
    }
    p "end client"
@@ -189,4 +189,40 @@ if ARGV.size==0 || ARGV[0]=="5"
   sleep 10
 end
 
+if ARGV.size==0 || ARGV[0]=="6"
+  th=MServerAgent.run(2222,"localhost",22) do |chan|
+    puts "sv: connect"
+    @lchan||={}
+    @lchan[chan]=chan
+    chan.on_message do |mess| 
+      puts "sv: broadcast #{mess.inspect}..." 
+      @lchan.keys.each {|chan1|   chan1.send_message(mess) if chan1!=chan }
+      nil
+    end
+    chan.wait_end
+    @lchan.delete(chan)
+  end
+  lth=[]
+  5.times {
+    puts "####################### Run Client ########################"
+    lth << MClientAgent.run("localhost",2222) do |chan|
+      nb=0
+      chan.on_timer(100*rand(5..15)) { 
+        chan.send_message(["C",1,2,1.2,Time.now.to_f,true]) 
+        nb+=1
+        (chan.close rescue nil)if nb>50
+      }
+      chan.on_message { |mess| p "cli: receive: #{mess.inspect}" ; nil}
+      chan.wait_end
+      puts "client closed"
+    end
+    sleep rand(1..2)
+  }
+  sleep 10
+  puts "\n\n############# Kill all agents...\n\n"
+  lth.each { |th| th.kill} 
+  th.shutdown
+  sleep 2
+end
+
 puts "Test End !"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: minitcp
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.15.0
 platform: ruby
 authors:
 - Regis d'Aubarede
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-09-24 00:00:00.000000000 Z
+date: 2015-04-02 00:00:00.000000000 Z
 dependencies: []
 description: |
   A DSL for programming little Tcp client and server
@@ -18,25 +18,24 @@ extensions: []
 extra_rdoc_files: []
 files:
 - CHANGELOG.txt
-- lib/minitcp.rb
 - LICENSE
-- minitcp.gemspec
-- Rakefile.rb
 - README.md
+- Rakefile.rb
+- VERSION
+- lib/minitcp.rb
+- minitcp.gemspec
+- samples/README.md
 - samples/name_server.rb
-- samples/pingpongplot.rb
-- samples/plot.rb
 - samples/proxy.rb
-- samples/README.md
-- samples/relay/c.rb
+- samples/pxy.rb
+- samples/relay.rb
 - samples/relay/README.md
-- samples/relay/relaiproxy.rb
+- samples/relay/c.rb
 - samples/relay/relai_config.data
-- samples/relay.rb
+- samples/relay/relaiproxy.rb
 - samples/spdy.rb
 - samples/statcpu.rb
 - test.rb
-- VERSION
 homepage: https://github.com/glurp/minitcp
 licenses:
 - LGPL
@@ -57,15 +56,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.1.7
+rubygems_version: 2.4.6
 signing_key: 
 specification_version: 3
 summary: A DSL for programming little Tcp client and server
 test_files:
 - samples/name_server.rb
-- samples/pingpongplot.rb
-- samples/plot.rb
 - samples/proxy.rb
+- samples/pxy.rb
 - samples/README.md
 - samples/relay.rb
 - samples/spdy.rb

data/samples/pingpongplot.rb

@@ -1,26 +0,0 @@
-# LGPL,  Author: Regis d'Aubarede <regis.aubarede@gmail.com>
-#################################################################
-#  pingpongplot.rb : measure pingpong time on google, plot it
-#
-# Usage :
-#   > ruby pingpongplot.rb  | ruby plot.rb 0 0 300 pingpong auto
-#################################################################
-require_relative '../lib/minitcp.rb'
-
-
-$stdout.sync=true
-
-MClient.run_continious("google.com",80,100) do |socket|
-  s=Time.now.to_f
-  socket.on_receive_sep("\r\n") do |data| 
-  	$stdout.puts("#{(Time.now.to_f-s)*1000}") 
-  	socket.close rescue nil
-  	Thread.current.kill
-  end
-  s=Time.now.to_f
-  socket.print "GET /blabla HTTP/1.0\r\n\r\n"
-  socket.wait_end
-end
-
-
-sleep

data/samples/plot.rb

@@ -1,190 +0,0 @@
-# LGPL
-###############################################################
-# plot.rb plot data(s) of stdin to Gui display
-# Usage:
-#  > vmstat 1 | ruby  plot.rb -2 0-value 100%-value cpu --  10  0 5000 io auto
-#                             ^input-column         ^label  ^in-column .. ^auto-scale
-#      
-###############################################################
-
-require 'Ruiby'
-$bgcolor=::Gdk::Color.parse("#023")
-$fgcolor=[
-	::Gdk::Color.parse("#FFAA00"),
-	::Gdk::Color.parse("#99DDFF"),
-	::Gdk::Color.parse("#00FF00"),
-	::Gdk::Color.parse("#0000FF"),
-	::Gdk::Color.parse("#FFFF00"),
-	::Gdk::Color.parse("#00FFFF"),
-	::Gdk::Color.parse("#FF00FF"),
-	::Gdk::Color.parse("#999"),
-]
-class Measure
-	class << self
-		def create(argv)
-			noc=argv.shift.to_i
-			y0=(argv.shift||"0.0").to_f
-			y1=(argv.shift||"100.0").to_f
-			label=argv.shift||"?"
-			autoscale=argv.size>0
-			@lcurve||=[]
-			@lcurve << Measure.new(noc,y0,y1,label,autoscale)
-			@lcurve.size-1
-		end
-		def add(noc,y0,y1,label,autoscale)
-			@lcurve << Measure.new(noc,y0,y1,label,autoscale)
-			@lcurve.size-1
-		end
-		def scan_line(line)
-			nums=line.scan(/[\d+.]+/)
-			@lcurve.each { |m| m.register_value(nums) }
-		end
-		def add_value(index,value)
-			@lcurve[index].register_value(value)
-		end
-		def draw_measures(ctx)
-			@lcurve.each_with_index { |m,index| m.plot_curve(index,ctx) }
-			@lcurve.each_with_index { |m,index| m.plot_label(index,ctx) }
-		end
-	end
-	def initialize(noc,min,max,label,auto_scale)
-	  @noc=noc
-	  @div,@offset=calc_coef(min,0.0,max,1.0)
-	  @name=label
-	  @value= 0
-	  @curve=[]
-	  @label=@name
-	  @autoscale=auto_scale
-	end
-	def register_value(data)
-		if data.is_a? Array
-			svalue=data[@noc]
-			return if !svalue || svalue !~ /[\d.]+/
-			@value=svalue.to_f
-		else
-			@value=data
-		end
-		@label = "%s %5.2f" % [@name,@value]
-		v= @value * @div + @offset
-		py=[0.0,(H-HHEAD)*1.0,(H-HHEAD)*(1.0-v)].sort[1]+HHEAD
-		@curve << [W+PAS,py,v,@value]
-		@curve.select! {|pt| pt[0]-=PAS; pt[0]>=0}
-	    p [i,@value,v,py] if $DEBUG
-	    auto_scale if @autoscale && @curve.size>5
-	end
-	def auto_scale()
-		min,max=@curve.minmax_by {|pt| pt[2]}
-		if min!=max && (min[2]<-0.01 || max[2]>1.01)
-		   p "correction1 #{@name} #{min} // #{max}"
-		   @div,@offset=calc_coef(min[3],0.0,max[3],1.0)
-		   @curve.each {|a| a[2]=a[3]*@div+@offset ; a[1] = (H-HHEAD)*(1-a[2])}
-		elsif (d=(max[2]-min[2]))< 0.1 && (@curve.size-1) >= W/PAS && d>0.0001
-		   p "correction2 #{@name} #{min} // #{max}"
-		   @div,@offset=calc_coef(min[3],min[2]-3*d,max[3],max[2]+3*d)
-		   @curve.each {|a| a[2]=a[3]*@div+@offset ; a[1] = (H-HHEAD)*(1.0-a[2])}			
-		end
-	end
-	def calc_coef(x0,y0,x1,y1)
-		y0=[0.0,1.0,y0].sort[1]
-		y1=[0.0,1.0,y1].sort[1]
-		a=1.0*(y0-y1)/(x0-x1)
-        b= (y0+y1-(x0+x1)*a)/2
-        [a,b]
-	end
-	def plot_curve(index,ctx)
-		return if @curve.size<2
-		a,*l=@curve
-		style(ctx,3,$fgcolor.last)   ; draw(ctx,a,l)
-		style(ctx,1,$fgcolor[index]) ; draw(ctx,a,l)
-	end
-	def style(ctx,width,color)
-		ctx.set_line_width(width)
-		ctx.set_source_rgba(color.red/65000.0,color.green/65000.0,color.blue/65000.0, 1.0)
-	end
-	def draw(ctx,h,t)
-		ctx.move_to(h.first,h[1])
-		t.each {|x,y,*q| ctx.line_to(x,y) }
-		ctx.stroke   
-	end		
-	def plot_label(index,ctx)
-		style(ctx,3,$fgcolor[index]) 
-		ctx.move_to(5+60*index,HHEAD-5)
-		ctx.show_text(@label)
-	end
-end
-
-
-def run(app)
-	$str=$stdin.gets
-	if $str
-		p $str if $DEBUG
-		Measure.scan_line($str)
-		gui_invoke { @cv.redraw }
-	else 
-		exit!(0)
-	end
-end
-
-def run_window()
-	Ruiby.app width: W, height: H, title: "Curve" do
-		stack do
-			@cv=canvas(W,H) do
-				on_canvas_draw { |w,ctx| expose(w,ctx) } 
-	        end		
-			popup(@cv) do
-				pp_item(" Plot ")	{  }
-				pp_separator
-				pp_item("htop") { system("lxterminal", "-e", "htop") }
-				pp_item("Gnome Monitor") { Process.spawn("gnome-system-monitor") }
-				pp_item("Terminal") { system("lxterminal") }
-				pp_separator
-				pp_item("Exit")	{ ask("Exit ?") && exit(0) }
-			end
-		end
-		chrome(false)
-		move($posxy[0],$posxy[1])
-	    @ow,@oh=size
-		def expose(cv,ctx)
-			ctx.set_source_rgba($bgcolor.red/65000.0, $bgcolor.green/65000.0, $bgcolor.blue/65000.0, 1)
-			ctx.rectangle(0,0,W,H)
-			ctx.fill()
-			ctx.set_source_rgba($bgcolor.red/65000.0, $bgcolor.green/65000.0, 05+$bgcolor.blue/65000.0, 0.3)
-			ctx.rectangle(0,0,W,HHEAD)
-			ctx.fill()		
-			Measure.draw_measures(ctx)
-			(puts "source modified!!!";exit!(0)) if File.mtime(__FILE__)!=$mtime 
-		end
-		$mtime=File.mtime(__FILE__)
-
-		Thread.new(self) { |app|  loop { run(app) } }
-	end
-end
-
-############################### Main #################################
-
-if $0==__FILE__
-	trap("TERM") { exit!(0) }
-
-	PAS=2
-	HHEAD=20
-	$posxy=[0,0]
-
-	if  ARGV.size>=2 && ARGV[0]=="--pos"
-	  _,posxy=ARGV.shift,ARGV.shift
-	  $posxy=posxy.split(/[x,:]/).map(&:to_i)
-	end  
-	if  ARGV.size>=2 && ARGV[0]=="--dim"
-	  _,geom=ARGV.shift,ARGV.shift
-	  W,H=geom.split(/[x,:]/).map(&:to_i)
-	else
-		W,H=200,100
-	end  
-
-	while ARGV.size>0
-	  argv=[]
-	  argv << ARGV.shift  while ARGV.size>0 && ARGV.first!="--"
-	  Measure.create(argv)
-	  ARGV.shift if ARGV.size>0 && ARGV.first=="--"
-	end
-	run_window
-end