minitcp 0.10.0

data/samples/plot.rb

@@ -0,0 +1,190 @@
+# 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

data/samples/proxy.rb

@@ -0,0 +1,46 @@
+#!/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
+####################################################
+require_relative '../lib/minitcp.rb'
+
+$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

@@ -0,0 +1,41 @@
+relaiproxy.rb
+==============
+
+An extranet server want to send command (http/soap) to a intranet http-server. 
+this intranet server (equipments/soap) are many and vairables.
+
+So realiproxy.rb define 2 process :
+* intranet side: **relai** :  maintain pool of sockets open with the proxy (initiated by a http request) 
+* extranet-side: **relaiproxy** : receive soap request and send them to relai via  pool sockets
+
+
+Schema
+======
+
+```
+                                                                        h[XX]=[ip,80,/]
+request--------http://proxy_hostname:prox-port/XX-------------------------------->>>> http://ip:80/
+      <--------------------------------------------------------------------------response
+      
+                        =================      firewal     =========
+Server ---------------> |  proxy-relai  | <------//--------| relai | ------------>>>> hosts
+                        =================                  =========
+         proxy-hostname                 proxy-ip                            ( config h[borne]= [ip,port,path] )
+             proxy-port                 proxy-port
+\___________________________________________/          \_______________/           .............
+           internet server                              server-in-intranet         intranet hosts
+```
+
+
+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)
+
+

data/samples/relay/c.rb

@@ -0,0 +1,21 @@
+require 'minitcp'
+require 'open-uri'
+
+Thread.abort_on_exception=true
+
+lfile=Dir.glob("*.*").reject {|f| File.extname(f)==".pdf" || f=~/\s/}.select {|f| !File.directory?(f) && f.size<20000}[0..3000]
+p lfile
+
+(ARGV[0]||"1").to_i.times do
+  Thread.new { loop {
+    fn=lfile[rand(lfile.size)-1]
+    s=Time.now
+    timeout(10) {
+      data=(open("http://localhost:2200/ruby/local/#{fn}?ChargeBoxId=%3ETOTO%3C").read rescue nil)
+      data||=""
+      puts "Received size=%-5d/%-5d/miss %10d for %-30s duree=%d  ms" % [data.size,File.size(fn),File.size(fn)-data.size,fn,((Time.now.to_f-s.to_f)*1000).to_i]
+      #sleep 0.4
+    } rescue p $! 
+  }}
+end
+sleep

data/samples/relay/relai_config.data

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

data/samples/relay/relaiproxy.rb

@@ -0,0 +1,180 @@
+#!/usr/bin/ruby
+# LGPL
+#################################################################################
+# relaiproxy.rb : An extranet server want to send command (http/soap)
+#                 to a intranet client_socket clients are many, variables, 
+#                 so NAT is not a solution.
+#
+#           relai.rb : in intranet, maintain the socket open with the proxy (initiated by a http request) 
+#           relaiproxy : receive soap request and send them to relai via open socket
+# so
+#   a pool of sockets beetwen intranet/extranet is maintain, client is inside intranet, 
+#   serveur is outside.
+#   server can send http request to intranet host via proxy-relai 
+#   'plugin' in relai can determine host adresse with the request contant (header SOAP...)
+#
+#################################################################################
+=begin
+                                                                        h[XX]=[ip,80,/]
+request--------http://proxy_hostname:prox-port/XX-------------------------------->>>> http://ip:80/
+      <--------------------------------------------------------------------------response
+                        =================      firewal     =========
+Server ---------------> |  proxy-relai  | <------//--------| relai | ------------>>>> hosts
+                        =================                  =========
+         proxy-hostname                 proxy-ip                            ( config h[borne]= [ip,port,path] )
+             proxy-port                 proxy-port
+\___________________________________________/          \_______________/           .............
+           internet server                              server-in-intranet         intranet hosts
+=end
+
+#require 'minitcp'
+require_relative 'minitcp/lib/minitcp.rb'
+
+if ARGV.size<1
+  puts"Usage>"
+  puts"  #{$0} type hostname port"
+  puts"  #{$0} proxyhttp  proxy-hostname proxy-port"
+  puts"  #{$0} relai      proxy-saia-ip  proxy-saia-port  plugin"
+  exit(1)
+end
+
+$opt,$host,$port=ARGV[0]||"proxyhttp",ARGV[1]||"localhost",ARGV[2]||80
+
+NBDIGITHEAD=8
+QUEUE_SIZE=100
+
+def sformat(socket,mess) 
+  socket.send("%-#{NBDIGITHEAD}d%s" % [mess.size,mess],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) : ""
+end
+def log(t) puts "%10s | %s" % [Time.now.to_s,t] end
+
+if $opt=="proxyhttp"
+##################################################################################
+##                              P R O X Y
+##################################################################################
+
+$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]
+  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
+  ensure
+    $queue.push(relai)
+  end
+end
+
+############# serveur http  machine distante #######################
+
+MServer.service($port.to_i+1,"0.0.0.0",22) do |s_cli|
+  puts "> ======== relai is Connected ========"
+  $client_sockets[s_cli]=true
+  $queue.push s_cli
+  s_cli.wait_end
+  puts "> ======== relai deConnected "
+  $client_sockets.delete(s_cli)
+end
+
+else
+
+##################################################################################
+##                              R E L A Y
+##################################################################################
+CONF="relai_config.data"
+plugin=ARGV.last||"ocpp"
+p plugin
+$config=nil
+$configtime=nil
+
+def load_config()
+  return if  $configtime!=nil && $configtime.to_f == File.mtime(CONF).to_f
+  begin
+    log("load config...")
+    File.open(CONF) { |f| $config=eval( f.read.strip ) }
+    log("load config ok, nb-host=#{$config.size} ...")
+    $configtime=File.mtime(CONF)
+  rescue
+    log("Error loading configration : #{$!}")
+  end
+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]
+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}")
+  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
+    end
+  }.join
+  response
+end
+
+QUEUE_SIZE.times do
+  MClient.run_continious($host,$port.to_i+1,1000) do |socket|
+    nbr=0
+    socket.on_n_receive(NBDIGITHEAD) do |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
+    end
+    socket.wait_end
+  end
+end
+
+end
+sleep

data/samples/relay.rb

@@ -0,0 +1,102 @@
+# LGPL,  Author: Regis d'Aubarede <regis.aubarede@gmail.com>
+#################################################################
+#  relay.rb : estabish connexion between 2 agents
+#  One agent open a (http like) connection as 'server', with his name
+#  A 'client' ask a connection to a 'server', with the name of server
+#     if sever connection is alive
+#        server receive an 'CONNECTED' message,with the name of client
+#        socket server is IO.copy with client socket
+#        server should establish a new 'server' connection for other client
+#
+#
+#################################################################
+require_relative '../lib/minitcp.rb'
+
+BasicSocket.do_not_reverse_lookup = true
+Thread.abort_on_exception = true
+
+$SIZE=30
+$dico_name={}
+$dico_ip={}
+
+def run_net_relay()
+  MServer.service(4410,"0.0.0.0",1000) do |socket| 
+    socket.on_n_receive($SIZE) do |data|
+      ip=socket.remote_address.ip_address
+      cmd,url,http=data.split(' ')  
+      name,method,*args=url.split('/').last
+      next if cmd!="GET"  
+      case method
+      when "server"
+        old=ActiveConnection.search(name)
+        if old && old.state==:free
+           old.deconnect
+           old=nil
+        end
+        if !old || old.state==:connected
+          ActiveConnection.add(socket)
+        end
+      when "client"
+        if srv=ActiveConnection.search(args.first)
+          srv.connect_to(name)
+        else
+          smess("NOTCONNECT")
+        end
+      end
+      rep=""
+    end
+  end
+end
+
+def smess(socket,*args)
+    data=  args.join(";")+";"
+    socket.send(data+" "*($SIZE-data.length),0) rescue p $!
+end
+
+def run_server_name()
+  MServer.service(4400,"0.0.0.0",100) do |socket| 
+    socket.on_n_receive($SIZE) do |data|
+      ip=socket.remote_address.ip_address
+      cmd,*args=data.split(";")  
+      name=args.first
+      rep=""
+      case cmd
+        when "update"
+          $dico_name[name]=ip
+          $dico_ip[ip]=name
+          rep="OK"
+        when "forget"
+          oldip=$dico_ip[ip]
+          if oldip && $dico_ip[ip]==name && $dico_name[name]==ip
+            $dico_name.delete(name)
+            $dico_ip.delete(ip)
+            rep="OK"
+          end
+        when "get"
+          rep=$dico_name[name].to_s
+        when "geti"
+          rep=$dico_ip[name].to_s
+      end
+      rep.size>0  ? smess(socket,"ACK",name,rep) : smess(socket,"NACK","NOK","NOK")
+    end
+    socket.after(10*1000) { socket.close rescue nil}
+    socket.wait_end
+  end
+end
+
+################# Client api ########################
+
+if $0==__FILE__
+  run_server_name
+  
+  Thread.new { 4.times { update_server_name("glurp") ; sleep 1 } }
+  Thread.new { 4.times { update_server_name("glurp22") ; sleep 1 } }
+
+  sleep 2
+  puts "\n\n***************** get name *******************\n\n"
+
+  p fetch_name("glurp")
+  p fetch_ip("127.0.0.1")
+  forget_me("glurp22")
+  sleep
+end

data/samples/spdy.rb

@@ -0,0 +1,43 @@
+#!/usr/bin/ruby
+# LGPL
+####################################################
+# spdy.rb : pure spdy relay : recieve SPDY cnnexion,
+#           send http request to a http server, 
+#   > ruby spdy.rb target-hostname target-port 
+####################################################
+require_relative '../lib/minitcp.rb'
+
+$host,$port,$opt=ARGV[0]||"localhost",ARGV[1]||80
+puts "Server SPDY:// on port 2200, proxy to #{$host}:#{$port}..."
+
+class SPDY
+	HEADER_SIZE=8 # 8 bytes, [2 version,2 type,1 flags,3 length(24)],data[length]
+	class << self
+		def  control_frame_decode(data)
+			cbit=(data[0].ord&0x80)!=0
+			if cbit && data.size==8
+				version=(data[0].ord&0x7F)*256+data[1].ord
+				type= data[2].ord*256+data[3].ord
+				iflag= data[4].ord
+				length=(data[5].ord*256+data[6].ord)*256+data[7].ord
+			end
+		end
+	end
+end
+
+
+MServer.service(2200,"0.0.0.0",22) do |s_cli|
+  puts "> ======== client Connected ========"
+  on_n_receive(SPDY::HEADER_SIZE) do |header|
+	version,type,flags,length=SPDY.control_frame_decode(header)
+	data= length>0 ? receive_n_bytes(length) : ""
+    srv=MClient.run_one_shot($host,$port) do |s_srv|
+  end
+  s_cli.wait_end
+  p "end cli, stop proxy"
+  srv.kill
+end
+
+sleep
+
+

data/samples/statcpu.rb

@@ -0,0 +1,37 @@
+# LGPL
+# ruby b.rb  0.2  3 | ruby plot.rb --pos 300,0  0 -0.01 1 cpu
+
+if File.exists?("c:/windows")
+	require 'ruby-wmi'
+
+	puts "Not implemented for Windows !!!"
+	exit(0)
+else
+
+def get_nbcpu()
+	stat = Hash[*(IO.read("/proc/stat").split("\n").map {|line| line.chomp.split(/\s+/,2)}.flatten)]
+	stat.keys.grep(/^cpu(\d+)/).size
+end
+def get_stat()
+	stat = Hash[*(IO.read("/proc/stat").split("\n").map {|line| line.chomp.split(/\s+/,2)}.flatten)]
+	p stat if $DEBUG
+	stat=stat["cpu"].split(/\s+/).map(&:to_i)
+end
+
+
+$stdout.sync=true
+periode= ARGV.shift.to_f
+lno=ARGV.map(&:to_i)
+p periode
+p lno
+nbcpu=get_nbcpu()
+p nbcpu
+ref=get_stat()
+loop {
+		ref=get_stat().tap {|t|
+			x=t.zip(ref).map {|a,b| ((a-b)*10)/(nbcpu*periode*1000)} 
+		    puts lno.map {|i| (100*x[i]).to_i}.join(" ")
+	    }
+		sleep periode
+}
+end