minitcp 0.10.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 5a5ea8ac3aaaa06e3051b9d4e696713132b1e721
+  data.tar.gz: 98eb5966f3ff14ca68c1522110b6fdd3d941b3d3
+SHA512:
+  metadata.gz: 87f235759fc78198cbeeb0446b788c685f4c82ca79947fe551f0822da7c29e5fb7961e756eec422b524d92d2821688871caeaee01ac502d831d093aa598288f5
+  data.tar.gz: d217d33d86b4181190730605dfe88ccbfc3405eeb022521ae8fab0b32041a4ed57d7a199c73fc34fa7bf0836c9e3a3cbb36e99aad413e1d65bf1a89b665e95bf

data/CHANGELOG.txt

@@ -0,0 +1,42 @@
+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
+0.7.0 : 2014-09-18 22:37:45 +0200
+    README.md : titles
+    test.rb : UDP tests
+    minitcp.rb : udp creation
+    README.md : UDP creation
+    statcpu.rb : windows version, not finish...
+    README.md : spdy start demo
+    README.md : best code example
+    README.md : presentation
+    README.md : continious
+0.6.1
+    plot.rb : refactoring Measure.class
+    pingpongplot.rb : temporisation
+0.6.0 : 2014-08-21 11:06:44 +0200
+    README.md : todo
+    plot.rb : auto-scale
+    name_server.rb : creation
+    plot.rb : color
+    plot.rb : interaction with mouse
+    name_server.rb : forget debug
+0.5.0 : 2014-08-18 16:39:35 +0200
+0.4.0 : 2014-08-18 16:37:12 +0200
+    minitcp.rb : error on stdout for SocketReactive
+    README.md : typo
+    README.md : sockets presentation
+    README.md : rdoc url
+    minitcp.rb : comments
+    README.md : presentations, format
+    proxy.rb : prefix correction
+    README.md : proxy correction
+    README.md : todo, presentation
+0.3.0 : 2014-08-18 01:27:40 +0200
+    test.rb : sleep before thread good stoping detection
+    minitcp.rb : all read hendler do socket close when necessary
+    README.md : todo
+0.2.0 : 2014-08-17 16:07:03 +0200
+    Rakefile.rb : update
+    test.rb : license
+    proxy.rb : license

data/LICENSE

@@ -0,0 +1,2 @@
+
+LGPL

data/README.md

@@ -0,0 +1,200 @@
+Minitcp
+===
+
+Presentation
+==
+
+A little tool for doing some TCP/UDP sockets communications.
+
+This tool have no pretention : it is not EventMachine ! : 
+
+* no mainloop, 
+* many threads are created/deleted.
+* it is useful for send some data one-shot, test a ascii communication in few minutes...
+* should be equivalent to netcat+bash ...
+
+
+A  TCP client :
+
+```ruby
+MClient.run_one_shot("localhost",2200) do |socket|
+   socket.on_any_receive { |data| p "client recieved #{data.inspect}"}
+   3.times { |j| socket.puts "Hello  #{j}..." ; sleep(1) }
+end.join
+```
+
+An echo server :
+
+```ruby
+srv=MServer.service(2200,"0.0.0.0",22) do |socket|
+  socket.on_any_receive { |data|  socket.print(data) }
+  socket.on_timer(2000) do
+    socket.close
+  end
+  socket.wait_end
+end
+```
+
+A UDP server :
+
+```ruby
+	UDPAgent.on_datagramme("127.0.0.2",SRV_PORT ) { |data,from,p| 
+	  puts "Agent: received #{data} from #{from}:#{p}" 
+	  data && data.size>3 ? "OK-#{data}." : nil
+	}
+```
+
+A UDP sender :
+
+```ruby
+	UDPAgent.on_timer(1000, 
+		port: 2232,
+		on_timer: proc do
+		  data=Time.now.to_i.to_s
+		  puts "\n\n\non timer send <#{data}>"
+		  {mess: data,host: "127.0.0.2",port: SRV_PORT}
+		end,
+		on_receive: proc { |data,from,sock| 
+		  puts "Client: received #{data} from #{from}"  
+		  UDPAgent.send_datagram_on_socket(sock,from.last,from[1],'ack')
+		}
+	)
+```
+
+
+Docs: http://rubydoc.info/gems/minitcp
+
+
+TCP
+===
+
+Client
+---
+
+```
+MClient.run_one_shot(host,port) do |socket| ... end
+MClient.run_continious(host,port,time_inter_connection) do |socket| ... end
+```
+
+Client socket is extended with all specifiques commandes (```SocketReactive```, see Sockets).
+
+Server
+---
+
+```ruby
+srv=MServer.service(port,"0.0.0.0",max_client) do |socket| ... end
+```
+Mserver run a GServer. 
+Connected sockets are extended with same module as in client.
+
+Sockets
+---
+
+Handlers are disponibles for any sockets : client or server. 
+All handler's bloc run in distinct thread : so any handler-bloc can wait anything.
+if socket is closed, handler/thread are cleanly (?) stoped.
+
+* socket.**on_any_receive() {|data| ...}**          : on receive some data, any size
+* socket.**on_n_receive(sizemax=1) {|data| ...}**   : receives n byte(s) only
+* socket.**on_receive_sep(";") {|field | ... }**    : reveive data until string separator
+* socket.**on_timer(value_ms) { ... }**             : each time do something, if socket is open
+* socket.**after(duration) { ... }**    : do something after n millisecondes, if socket is open
+
+Some primitives are here for help (no thread):
+
+* **received_timeout(sizemax,timeout)** : wait for n bytes, with timeout, (blocking caller),
+* **wait_end()**                        : wait, (blocking caller) until socket is close. this
+  work only if something has closed the socket.this is possible unicly by receiving 0 bte on a
+* **receive_n_bytes** / **on_receive_sep** : bocking version of handler,
+* **connected?** : test if a close have been done,  
+* **data_readed()** : some receives (receive_sep...) can read more data form sockets,
+ this data are used by ```n_revieve/any_receive/receive_sep```, but they can be read/reseted 
+ whith data_readed getseter.
+
+This primitives are declared in SocketReactive module.
+
+UDP
+===
+
+2 type of agents : 
+
+* **Server** : receive data from anywhere, can reply to sender
+* **Timer**  : emit to everybody, can receive response to them
+
+2 primitives :
+
+* **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
+
+
+TODO
+==
+
+* Serial line
+* more socket primitive
+
+
+Tests case
+==
+A TCP proxy, debug tool (see samples/proxy.rb) :
+
+```ruby
+MServer.service(2200,"0.0.0.0",22) do |scli|
+  px 2, "======== client Connected ========"
+  srv=MClient.run_one_shot("ip",2200) do |ssrv|
+     px 1, "======== server Connected ========"
+     ssrv.on_any_receive { |data| px 1,data; scli.print data }
+     scli.on_any_receive { |data| px 2,data; ssrv.print data}
+     ssrv.wait_end
+     scli.close rescue nil
+  end
+  scli.wait_end
+  srv.stop rescue nil
+end   
+def px(sens,data)
+  data.each_line {|line| puts "#{(sens==1 ? "> " : "< ")}#{line.chomp}"
+end
+
+```
+
+
+
+
+Test serial **protocole-like** : header/body => ack/timeout:
+
+* client send <length><data> , wait one char acquit or timeout
+* serveur receive heade( size: 4 chars) , then data with size, send ack
+
+
+```ruby
+   
+srv=MServer.service(2200,"0.0.0.0",22) do |socket|
+  socket.on_n_receive(4) { |data| 
+     size=data.to_i
+     data=socket.recv(size)
+     puts "  Server recieved buffer : #{data.inspect}"
+     if rand(100)>50
+        socket.print("o") 
+     else 
+        puts "  !!!non-ack by serv"
+     end
+  }
+  socket.on_timer(40*1000) { puts " serv close after 40 seconds"; socket.close }
+  socket.wait_end
+end   
+
+MClient.run_one_shot("localhost",2200) do |socket|
+   10.times { |j| 
+	   size=rand(1..10)
+	   puts "Sending #{size} data..."
+	   data='*'*size
+	   socket.print "%04d" % size
+	   socket.print data 
+	   p socket.received_timeout(1,100)  ? "ack ok" : "!!! timeout ack"
+   }
+   p "end client"
+end.join
+
+
+```
+

data/Rakefile.rb

@@ -0,0 +1,217 @@
+# Creative Commons BY-SA :  Regis d'Aubarede <regis.aubarede@gmail.com>
+# LGPL
+#################################################################
+#  Rakefile : git commit/add ; git push, test/spec & gem push
+#################################################################
+#
+# Usage:
+# > rake commit  # commit in local directory and push to repository
+# > rake gem     # make gem,and test it, and push it to gemcutter
+# > rake travis  # travis CI run commands
+#
+#################################################################
+#  Requirements :
+#   version : X.Y.Z  
+#           X : to be hand-modified 
+#           Y : incremented at each 'rake gem'
+#           Z : increment on each file 'rake commit'
+#   auto commit all changed file, sking comment for each
+#   log all commment in CHANGELOG?Txt file
+#   increment VERSION content with version numbering rule
+#     so CHANGELOG.txt is updated with each comment/version change
+#     so VERSION is updated in each commit (Z part) and each gem build (Y part) 
+#   
+# commit:
+#   Use 'git status' output for each new/modified file,
+#   with asking some comment
+#   (no add/commit of comment is empty)
+#
+# gem:
+#   execute rspec if specs exists,
+#   make a gem, install it, execute samples/test.rb in it, if exist
+#   ask to operator if execution is ok and : 
+#      increment version
+#      update change log/version
+#      do a 'gem push' and a 'gem yanked'
+#    make a coffe
+#
+#################################################################
+
+FIGNORES=%w{VERSION CHANGELOG.txt .gitignore}
+NAME= Dir.pwd.gsub(File.dirname(Dir.pwd)+'/',"")
+
+Rake.application.options.trace = false
+
+def push_changelog(line)
+  b=File.read('CHANGELOG.txt').split(/\r?\n/) 
+  b.unshift(line)
+  File.open('CHANGELOG.txt','w') {|f| f.write(b[0..500].join("\n")) }
+end
+def changelog_push_currrent_versions()
+  version=File.read('VERSION').strip
+  b=File.read('CHANGELOG.txt').split(/\r?\n/) 
+  b.unshift(version)  
+  File.open('CHANGELOG.txt','w') {|f| f.write(b.join("\n")) }
+  yield rescue p $!.to_s
+  b.shift  
+  File.open('CHANGELOG.txt','w') {|f| f.write(b.join("\n")) }
+end
+
+def change_version()
+  a=File.read('VERSION').strip.split('.')[0..2]
+  yield(a)
+  version=a.join('.') 
+  File.open('VERSION','w') {|f| f.write(version) }
+  version
+end
+def verification_file(fn)
+  return unless File.extname(fn)==".rb"
+  content=File.read(fn)[0..600]
+  unless content =~ /LGPL/
+    puts "\nFile #{fn} seem not contain licenses data LGPL\n"   
+    exit(0)
+  end
+end
+#############################################################
+#               Comment each file add/modified             ##
+#############################################################
+
+
+desc "commit file changed and created"
+task :commit_status do
+  `git status -s`.split(/\r?\n/).each do |line|
+  words=line.split(/\s+/)
+  case line
+    when /^ M /
+      filename=words[2]
+      next if FIGNORES.include?(filename)
+      system("git","diff",filename)
+      print("Comment for change in #{filename} : ")
+      comment=$stdin.gets
+      if comment && comment.chomp.size>0
+          comment.chomp!
+          (puts "Abort!";exit!)   if comment=~/^a(b(o(r(t)?)?)?)?$/
+          verification_file(filename)
+          sh "git commit #{filename} -m \"#{comment.strip}\"" rescue 1
+          push_changelog("    #{File.basename(filename)} : #{comment}")
+          $changed=true
+      end
+    when /^\?\?/
+      filename=words[1]
+      print("Comment for new file in #{filename} : ")
+      comment=$stdin.gets.chomp
+        (puts "Abort!";exit!)   if comment=~/^a(b(o(r(t)?)?)?)?$/
+      if comment =~ /^y|o/i
+        verification_file(filename)
+        sh "git add #{filename}"
+        sh "git commit #{filename} -m \"creation\"" rescue 1
+        $changed=true
+      end
+  end
+  end
+end
+
+
+#############################################################
+#  before commit
+#############################################################
+
+desc "job before commit"
+task :pre_commit do
+  sh "cls" if RUBY_PLATFORM =~ /(win32)|(mingw)/i 
+  puts <<EEND2
+
+
+--------------------------------------------------------------------
+                 Commmit and push #{NAME}
+--------------------------------------------------------------------
+EEND2
+  
+  #sh "giti"
+  $changed=false
+end
+
+#############################################################
+#  after commit
+#############################################################
+desc "job after local commit done: push to git repo"
+task :post_commit do
+  if $changed
+    $version=change_version { |a| a[-1]=(a.last.to_i+1) }  
+    sh "git commit VERSION -m update"
+    changelog_push_currrent_versions {
+      sh "git commit CHANGELOG.txt -m update"
+      sh "git push"
+      puts "\n\nNew version is #{$version}\n"
+    } 
+  else
+    puts "no change!"
+  end
+end
+
+#############################################################
+#   commit
+#############################################################
+desc "commit local and then distant repo"
+task :commit => [:pre_commit,"commit_status",:post_commit]
+
+
+#############################################################
+#  gem build & push
+#############################################################
+desc "make a gem and push it to gemcutter"
+task :gem  do
+  $version=change_version { |a| 
+      a[-2]=(a[-2].to_i+1) 
+      a[-1]=0 
+  }   
+  puts "New version ==>> #{$version}"
+  l=FileList['*.gem']
+  l.each { |fn| rm fn }
+  gem_name="#{NAME}-#{$version}.gem"
+  push_changelog  "#{$version} : #{Time.now}"
+  sh "gem build #{NAME}.gemspec"
+  Rake::Task["test"].execute    if File.exists?("samples/test.rb")
+  sh "gem push #{gem_name}"
+  l.each { |fn|
+    ov=fn.split('-')[1].gsub('.gem',"")
+    sh "gem yank -v #{ov} #{NAME}"
+  }
+end
+#############################################################
+#  execute tests 
+#############################################################
+
+desc "test the current version of the framework by installing the gem and run a test programme"
+task :test do
+ if File.exists?("spec/test_all.rb")
+  system("rspec spec/test_all.rb")
+ end
+ if File.exists?("samples/test.rb")
+   cd ".."
+   mkdir "#{NAME}Test" unless File.exists?("#{NAME}Test")
+   nname="#{NAME}Test/test.rb"
+   content=File.read("#{NAME}/samples/test.rb").gsub(/require_relative/," require").gsub('../lib/','')
+   File.open(nname,"w") { |f| f.write(content) }
+   sh "gem install #{FileList["#{NAME}/#{NAME}*.gem"][-1]}"
+   ruby nname rescue nil
+   cd NAME
+   print "\n\nOk for diffusion ? "
+   rep=$stdin.gets
+   raise("aborted!") unless rep && rep =~ /^y|o|d/
+ end
+end
+
+#############################################################
+#  travis command 
+#############################################################
+
+task :travis do
+ puts "Starting travis test..."
+ cmd="bundle exec rspec spec/test_all.rb"
+ system("export DISPLAY=:99.0 && #{cmd}")
+ #system(cmd)
+ raise "rspec failed!" unless $?.exitstatus == 0
+end
+
+

data/VERSION

@@ -0,0 +1 @@
+0.10.0