p2p2 0.6.7 → 0.6.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3a2f86bbf773a9d8c58099c2eecfb6d97ef0de25269a864d0566285ddd716d3a
-  data.tar.gz: d1ead80d1fbbecf687ddd0e47eb68ba44813134f52a23ee0ed135fe14c13a899
+  metadata.gz: c2ea64b1b56f96705f33185cd1d3453aa7dca90201c959a58c945d37a8b93de6
+  data.tar.gz: 1531971c59bfbb7733b90fdcc6bd0360c7515bde0feabeb1f11e54a91247e90c
 SHA512:
-  metadata.gz: 02af82e8959a69458fa5fb709386b2f4e283de4a71ccea60a0ddd2a1caf75801313f104140abe2b0394c5fdd7db46c8bbd6d7c745418e765b82c28a931221b44
-  data.tar.gz: 632689f40841f9bf7f75cc4dd111bba6bd619b4a4c24afbbd6e28828e5ed71772c0726474db082b26e129e067f679ef8a26686280c1f7dd657b05e550d833c51
+  metadata.gz: 2019e957258fccf58435115404570f2d82168ca2c1edc2a5236ada506ecc3fc194353b1729d42b231f79ab61d7321dfe1c23e888484df4fd4299abc97e9a620c
+  data.tar.gz: 7bc57270d19f9cf5bf40c2bb460eb091ea8212302d844d3589ef10ba3853b8d22495380580b841bc0f0a72a4179acc2e8d7d1e2afcdba93f5e0b9409463cf467

data/lib/p2p2/head.rb

@@ -2,10 +2,8 @@ module P2p2
   PACK_SIZE = 1448 # 包大小
   CHUNK_SIZE = PACK_SIZE * 1000 # 块大小
   REP2P_LIMIT = 5 # p2p重试次数。到早了另一头还没从洞里出来，会吃ECONNREFUSED，不慌，再来一发。
-  HEARTBEAT = 1
-  SET_TITLE = 2
-  PAIRING = 3
-  NEED_CHUNK = true
+  SET_TITLE = 1
+  PAIRING = 2
   CTL_CLOSE_ROOM = [ 1 ].pack( 'C' )
-  CTL_RENEW_ROOM = [ 2 ].pack( 'C' )
+  CTL_CLOSE_APP = [ 2 ].pack( 'C' )
 end

data/lib/p2p2/p1.rb

@@ -17,6 +17,7 @@ module P2p2
     # title         约定的房间名
     # app_chunk_dir 文件缓存目录，缓存app来不及写的流量
     # p1_chunk_dir  文件缓存目录，缓存p1来不及写的流量
+    #
     def initialize( roomd_host, roomd_port, appd_host, appd_port, title, app_chunk_dir = '/tmp', p1_chunk_dir = '/tmp' )
       @roomd_sockaddr = Socket.sockaddr_in( roomd_port, roomd_host )
       @appd_sockaddr = Socket.sockaddr_in( appd_port, appd_host )
@@ -28,10 +29,9 @@ module P2p2
       @reads = []
       @writes = []
       @closings = []
-      @renewings = []
       @roles = {}  # sock => :ctlr / :room / :p1 / :app
       @infos = {}
-      @retries = 0
+      @reconn_room = false
 
       ctlr, ctlw = IO.pipe
       @ctlw = ctlw
@@ -44,7 +44,7 @@ module P2p2
     def looping
       puts 'looping'
 
-      loop_renew_room
+      loop_expire
 
       loop do
         rs, ws = IO.select( @reads, @writes )
@@ -86,73 +86,90 @@ module P2p2
 
     private
 
-    def loop_renew_room
+    def loop_expire
       Thread.new do
         loop do
           sleep 60
 
           if Time.new - @room_info[ :updated_at ] > 600
             @mutex.synchronize do
-              @ctlw.write( CTL_RENEW_ROOM )
+              @ctlw.write( CTL_CLOSE_ROOM )
             end
           end
         end
       end
     end
 
-    def read_ctlr( sock )
-      case sock.read( 1 )
-      when CTL_RENEW_ROOM
-        add_renewing( @room )
+    ##
+    # read ctlr
+    #
+    def read_ctlr( ctlr )
+      case ctlr.read( 1 )
+      when CTL_CLOSE_ROOM
+        unless @room.closed?
+          add_closing( @room )
+        end
       end
     end
 
-    def read_room( sock )
+    ##
+    # read room
+    #
+    def read_room( room )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = room.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Errno::ECONNREFUSED, EOFError, Errno::ECONNRESET => e
         puts "read room #{ e.class } #{ Time.new }"
 
-        if @retries >= 2
+        if @reconn_room
           raise e
         end
 
         sleep 5
-        add_renewing( sock )
-        @retries += 1
+        add_closing( room )
+        @reconn_room = true
         return
       end
 
-      @retries = 0
-      info = @infos[ sock ]
+      @reconn_room = false
+      info = @infos[ room ]
       info[ :p2_sockaddr ] = data
       info[ :updated_at ] = Time.new
       new_p1
     end
 
-    def read_p1( sock )
+    ##
+    # read p1
+    #
+    def read_p1( p1 )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = p1.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Errno::ECONNREFUSED => e
-        if @room_info[ :rep2p ] >= REP2P_LIMIT
+        if @room_info[ :renew_p1_times ] >= REP2P_LIMIT
           raise e
         end
 
         sleep 1
-        add_renewing( sock )
-        @room_info[ :rep2p ] += 1
+        add_closing( p1 )
+        info = @infos[ p1 ]
+        info[ :need_renew ] = true
+        @room_info[ :renew_p1_times ] += 1
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( p1 )
         return
       end
 
-      @room_info[ :rep2p ] = 0
-      info = @infos[ sock ]
+      info = @infos[ p1 ]
+
+      if info[ :app ].nil? || info[ :app ].closed?
+        add_closing( p1 )
+        return
+      end
 
       if info[ :need_decode ]
         len = data[ 0, 2 ].unpack( 'n' ).first
@@ -161,20 +178,29 @@ module P2p2
         info[ :need_decode ] = false
       end
 
-      add_write( @app, data, NEED_CHUNK )
+      add_write( info[ :app ], data )
+      @room_info[ :updated_at ] = Time.new
     end
 
-    def read_app( sock )
+    ##
+    # read app
+    #
+    def read_app( app )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = app.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( app )
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ app ]
+
+      if info[ :p1 ].nil? || info[ :p1 ].closed?
+        add_closing( app )
+        return
+      end
 
       if info[ :need_encode ]
         data = @hex.encode( data )
@@ -182,54 +208,62 @@ module P2p2
         info[ :need_encode ] = false
       end
 
-      add_write( @p1, data, NEED_CHUNK )
+      add_write( info[ :p1 ], data )
+      @room_info[ :updated_at ] = Time.new
     end
 
-    def write_room( sock )
-      if @renewings.include?( sock )
-        close_sock( sock )
+    ##
+    # write room
+    #
+    def write_room( room )
+      if @closings.include?( room )
+        close_sock( room )
         new_room
         return
       end
 
-      info = @infos[ sock ]
-      data = info[ :wbuff ]
+      info = @infos[ room ]
+      room.write( info[ :wbuff ] )
+      @writes.delete( room )
+    end
 
-      if data.empty?
-        @writes.delete( sock )
-        return
-      end
+    ##
+    # write p1
+    #
+    def write_p1( p1 )
+      if @closings.include?( p1 )
+        info = close_sock( p1 )
+
+        if info[ :need_renew ]
+          new_p1
+          return
+        end
 
-      sock.write( data )
-      info[ :wbuff ].clear
-    end
+        unless info[ :app ].closed?
+          add_closing( info[ :app ] )
+        end
 
-    def write_p1( sock )
-      if @closings.include?( sock )
-        close_p1
-        return
-      end
+        unless @room.closed?
+          add_closing( @room )
+        end
 
-      if @renewings.include?( sock )
-        close_p1
-        new_p1
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ p1 ]
       data, from = get_buff( info )
 
       if data.empty?
-        @writes.delete( sock )
+        @writes.delete( p1 )
         return
       end
 
       begin
-        written = sock.write_nonblock( data )
+        written = p1.write_nonblock( data )
       rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( p1 )
         return
       end
 
@@ -237,31 +271,34 @@ module P2p2
       info[ from ] = data
     end
 
-    def write_app( sock )
-      if @closings.include?( sock )
-        close_sock( sock )
-
-        unless @p1.closed?
-          add_closing( @p1 )
+    ##
+    # write app
+    #
+    def write_app( app )
+      if @closings.include?( app )
+        info = close_sock( app )
+
+        unless info[ :p1 ].closed?
+          add_closing( info[ :p1 ] )
         end
 
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ app ]
       data, from = get_buff( info )
 
       if data.empty?
-        @writes.delete( sock )
+        @writes.delete( app )
         return
       end
 
       begin
-        written = sock.write_nonblock( data )
+        written = app.write_nonblock( data )
       rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( app )
         return
       end
 
@@ -292,27 +329,18 @@ module P2p2
     def add_closing( sock )
       unless @closings.include?( sock )
         @reads.delete( sock )
-        @closings <<  sock
+        @closings << sock
       end
 
       add_write( sock )
     end
 
-    def add_renewing( sock )
-      unless @renewings.include?( sock )
-        @reads.delete( sock )
-        @renewings <<  sock
-      end
-
-      add_write( sock )
-    end
-
-    def add_write( sock, data = nil, need_chunk = false )
+    def add_write( sock, data = nil )
       if data
         info = @infos[ sock ]
         info[ :wbuff ] << data
 
-        if need_chunk && info[ :wbuff ].size >= CHUNK_SIZE
+        if info[ :wbuff ].size >= CHUNK_SIZE
           filename = [ info[ :filename ], info[ :chunk_seed ] ].join( '.' )
           chunk_path = File.join( info[ :chunk_dir ], filename )
           IO.binwrite( chunk_path, info[ :wbuff ] )
@@ -332,7 +360,6 @@ module P2p2
       @reads.delete( sock )
       @writes.delete( sock )
       @closings.delete( sock )
-      @renewings.delete( sock )
       @roles.delete( sock )
       info = @infos.delete( sock )
 
@@ -348,14 +375,6 @@ module P2p2
       info
     end
 
-    def close_p1
-      close_sock( @p1 )
-
-      unless @app.closed?
-        add_closing( @app )
-      end
-    end
-
     def new_room
       room = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
       room.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
@@ -366,11 +385,11 @@ module P2p2
       rescue IO::WaitWritable, Errno::EINTR
       end
 
-      bytes = @title.unpack( "C*" ).map{ | c | c.chr }.join
+      title = @title.unpack( "C*" ).map{ | c | c.chr }.join
       room_info = {
-        wbuff: [ [ SET_TITLE, bytes.size ].pack( 'Cn' ), bytes ].join,
+        wbuff: [ [ SET_TITLE ].pack( 'C' ), title ].join,
         p2_sockaddr: nil,
-        rep2p: 0,
+        renew_p1_times: 0,
         updated_at: Time.new
       }
       @room = room
@@ -393,9 +412,18 @@ module P2p2
       rescue Exception => e
         puts "connect p2 #{ e.class } #{ Time.new }"
         p1.close
+        add_closing( @room )
         return
       end
 
+      app = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      app.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
+
+      begin
+        app.connect_nonblock( @appd_sockaddr )
+      rescue IO::WaitWritable, Errno::EINTR
+      end
+
       p1_info = {
         wbuff: '',
         cache: '',
@@ -403,21 +431,10 @@ module P2p2
         chunk_dir: @p1_chunk_dir,
         chunks: [],
         chunk_seed: 0,
-        need_decode: true
+        need_decode: true,
+        need_renew: false,
+        app: app
       }
-      @p1 = p1
-      @p1_info = p1_info
-      @roles[ p1 ] = :p1
-      @infos[ p1 ] = p1_info
-      @reads << p1
-
-      app = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
-      app.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
-
-      begin
-        app.connect_nonblock( @appd_sockaddr )
-      rescue IO::WaitWritable, Errno::EINTR
-      end
 
       app_info = {
         wbuff: '',
@@ -426,11 +443,13 @@ module P2p2
         chunk_dir: @app_chunk_dir,
         chunks: [],
         chunk_seed: 0,
-        need_encode: true
+        need_encode: true,
+        p1: p1
       }
 
-      @app = app
-      @app_info = app_info
+      @roles[ p1 ] = :p1
+      @infos[ p1 ] = p1_info
+      @reads << p1
       @roles[ app ] = :app
       @infos[ app ] = app_info
       @reads << app

data/lib/p2p2/p2.rb

@@ -17,6 +17,7 @@ module P2p2
     # title         约定的房间名
     # app_chunk_dir 文件缓存目录，缓存app来不及写的流量
     # p2_chunk_dir  文件缓存目录，缓存p2来不及写的流量
+    #
     def initialize( roomd_host, roomd_port, appd_host, appd_port, title, app_chunk_dir = '/tmp', p2_chunk_dir = '/tmp' )
       @roomd_sockaddr = Socket.sockaddr_in( roomd_port, roomd_host )
       @appd_sockaddr = Socket.sockaddr_in( appd_port, appd_host )
@@ -28,10 +29,13 @@ module P2p2
       @reads = []
       @writes = []
       @closings = []
-      @renewings = []
       @roles = {}  # sock => :appd / :app / :room / :p2
       @infos = {}
-      @retries = 0
+
+      ctlr, ctlw = IO.pipe
+      @ctlw = ctlw
+      @roles[ ctlr ] = :ctlr
+      @reads << ctlr
 
       new_appd
     end
@@ -39,12 +43,16 @@ module P2p2
     def looping
       puts 'looping'
 
+      loop_expire
+
       loop do
         rs, ws = IO.select( @reads, @writes )
 
         @mutex.synchronize do
           rs.each do | sock |
             case @roles[ sock ]
+            when :ctlr
+              read_ctlr( sock )
             when :appd
               read_appd( sock )
             when :app
@@ -58,12 +66,12 @@ module P2p2
 
           ws.each do | sock |
             case @roles[ sock ]
+            when :app
+              write_app( sock )
             when :room
               write_room( sock )
             when :p2
               write_p2( sock )
-            when :app
-              write_app( sock )
             end
           end
         end
@@ -79,9 +87,38 @@ module P2p2
 
     private
 
-    def read_appd( sock )
+    def loop_expire
+      Thread.new do
+        loop do
+          sleep 60
+
+          if @app && ( Time.new - @app_info[ :updated_at ] > 600 )
+            @mutex.synchronize do
+              @ctlw.write( CTL_CLOSE_APP )
+            end
+          end
+        end
+      end
+    end
+
+    ##
+    # read ctlr
+    #
+    def read_ctlr( ctlr )
+      case ctlr.read( 1 )
+      when CTL_CLOSE_APP
+        unless @app.closed?
+          add_closing( @app )
+        end
+      end
+    end
+
+    ##
+    # read appd
+    #
+    def read_appd( appd )
       begin
-        app, addr = sock.accept_nonblock
+        app, _ = appd.accept_nonblock
       rescue IO::WaitReadable, Errno::EINTR
         return
       end
@@ -100,7 +137,12 @@ module P2p2
         chunks: [],
         chunk_seed: 0,
         need_encode: true,
-        rbuff: ''
+        rbuff: '',
+        room: nil,
+        reconn_room: false,
+        p1_sockaddr: nil,
+        p2: nil,
+        renew_p2_times: 0
       }
       @app = app
       @app_info = app_info
@@ -111,17 +153,20 @@ module P2p2
       new_room
     end
 
-    def read_app( sock )
+    ##
+    # read app
+    #
+    def read_app( app )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = app.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( app )
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ app ]
 
       if info[ :need_encode ]
         data = @hex.encode( data )
@@ -129,61 +174,75 @@ module P2p2
         info[ :need_encode ] = false
       end
 
-      if @p2.nil?
-        info[ :rbuff ] << data
-      elsif @p2.closed?
-        info[ :rbuff ] << data
-        add_renewing( @room )
+      if info[ :p2 ]
+        add_write( info[ :p2 ], data )
       else
-        add_write( @p2, data, NEED_CHUNK )
+        info[ :rbuff ] << data
       end
+
+      info[ :updated_at ] = Time.new
     end
 
-    def read_room( sock )
+    ##
+    # read room
+    #
+    def read_room( room )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = room.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Errno::ECONNREFUSED, EOFError, Errno::ECONNRESET => e
         puts "read room #{ e.class } #{ Time.new }"
 
-        if @retries >= 2
+        if @app_info[ :reconn_room ]
           raise e
         end
 
         sleep 5
-        add_renewing( sock )
-        @retries += 1
+        add_closing( room )
+        @app_info[ :reconn_room ] = true
         return
       end
 
-      @retries = 0
-      info = @infos[ sock ]
-      info[ :p1_sockaddr ] = data
+      @app_info[ :reconn_room ] = false
+      @app_info[ :p1_sockaddr ] = data
+      @app_info[ :updated_at ] = Time.new
       new_p2
     end
 
-    def read_p2( sock )
+    ##
+    # read p2
+    #
+    def read_p2( p2 )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = p2.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Errno::ECONNREFUSED => e
-        if @room_info[ :rep2p ] >= REP2P_LIMIT
+        puts "read p2 #{ e.class } #{ Time.new }"
+
+        if @app_info[ :renew_p2_times ] >= REP2P_LIMIT
           raise e
         end
 
         sleep 1
-        add_renewing( sock )
-        @room_info[ :rep2p ] += 1
+        add_closing( p2 )
+        info = @infos[ p2 ]
+        info[ :need_renew ] = true
+        @app_info[ :renew_p2_times ] += 1
         return
       rescue Exception => e
-        add_closing( sock )
+        puts "read p2 #{ e.class } #{ Time.new }"
+        add_closing( p2 )
+        return
+      end
+
+      if @app.nil? || @app.closed?
+        add_closing( p2 )
         return
       end
 
-      @room_info[ :rep2p ] = 0
-      info = @infos[ sock ]
+      info = @infos[ p2 ]
 
       if info[ :need_decode ]
         len = data[ 0, 2 ].unpack( 'n' ).first
@@ -192,54 +251,42 @@ module P2p2
         info[ :need_decode ] = false
       end
 
-      add_write( @app, data, NEED_CHUNK )
+      add_write( @app, data )
+      @app_info[ :updated_at ] = Time.new
     end
 
-    def write_room( sock )
-      if @renewings.include?( sock )
-        close_sock( sock )
-        new_room
-        return
-      end
-
-      info = @infos[ sock ]
-      data = info[ :wbuff ]
-
-      if data.empty?
-        @writes.delete( sock )
-        return
-      end
-
-      sock.write( data )
-      info[ :wbuff ].clear
-    end
+    ##
+    # write app
+    #
+    def write_app( app )
+      if @closings.include?( app )
+        info = close_sock( app )
+
+        if info[ :room ] && !info[ :room ].closed?
+          add_closing( info[ :room ] )
+        end
 
-    def write_p2( sock )
-      if @closings.include?( sock )
-        close_p2
-        return
-      end
+        if info[ :p2 ] && !info[ :p2 ].closed?
+          add_closing( info[ :p2 ] )
+        end
 
-      if @renewings.include?( sock )
-        close_p2
-        new_p2
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ app ]
       data, from = get_buff( info )
 
       if data.empty?
-        @writes.delete( sock )
+        @writes.delete( app )
         return
       end
 
       begin
-        written = sock.write_nonblock( data )
+        written = app.write_nonblock( data )
       rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( app )
         return
       end
 
@@ -247,31 +294,58 @@ module P2p2
       info[ from ] = data
     end
 
-    def write_app( sock )
-      if @closings.include?( sock )
-        close_sock( sock )
+    ##
+    # write room
+    #
+    def write_room( room )
+      if @closings.include?( room )
+        close_sock( room )
+
+        unless @app.closed?
+          add_closing( @app )
+        end
+
+        return
+      end
+
+      info = @infos[ room ]
+      room.write( info[ :wbuff ] )
+      @writes.delete( room )
+    end
+
+    ##
+    # write p2
+    #
+    def write_p2( p2 )
+      if @closings.include?( p2 )
+        info = close_sock( p2 )
+
+        if info[ :need_renew ]
+          new_p2
+          return
+        end
 
-        unless @p2.closed?
-          add_closing( @p2 )
+        unless @app_info[ :room ].closed?
+          add_closing( @app_info[ :room ] )
         end
 
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ p2 ]
       data, from = get_buff( info )
 
       if data.empty?
-        @writes.delete( sock )
+        @writes.delete( p2 )
         return
       end
 
       begin
-        written = sock.write_nonblock( data )
+        written = p2.write_nonblock( data )
       rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( p2 )
         return
       end
 
@@ -302,27 +376,18 @@ module P2p2
     def add_closing( sock )
       unless @closings.include?( sock )
         @reads.delete( sock )
-        @closings <<  sock
-      end
-
-      add_write( sock )
-    end
-
-    def add_renewing( sock )
-      unless @renewings.include?( sock )
-        @reads.delete( sock )
-        @renewings <<  sock
+        @closings << sock
       end
 
       add_write( sock )
     end
 
-    def add_write( sock, data = nil, need_chunk = false )
+    def add_write( sock, data = nil )
       if data
         info = @infos[ sock ]
         info[ :wbuff ] << data
 
-        if need_chunk && info[ :wbuff ].size >= CHUNK_SIZE
+        if info[ :wbuff ].size >= CHUNK_SIZE
           filename = [ info[ :filename ], info[ :chunk_seed ] ].join( '.' )
           chunk_path = File.join( info[ :chunk_dir ], filename )
           IO.binwrite( chunk_path, info[ :wbuff ] )
@@ -342,7 +407,6 @@ module P2p2
       @reads.delete( sock )
       @writes.delete( sock )
       @closings.delete( sock )
-      @renewings.delete( sock )
       @roles.delete( sock )
       info = @infos.delete( sock )
 
@@ -358,10 +422,6 @@ module P2p2
       info
     end
 
-    def close_p2
-      close_sock( @p2 )
-    end
-
     def new_appd
       appd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
       appd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
@@ -369,7 +429,6 @@ module P2p2
       appd.bind( @appd_sockaddr )
       appd.listen( 511 )
 
-      @appd = appd
       @roles[ appd ] = :appd
       @reads << appd
     end
@@ -386,30 +445,29 @@ module P2p2
 
       bytes = @title.unpack( "C*" ).map{ | c | c.chr }.join
       room_info = {
-        wbuff: [ [ PAIRING, bytes.size ].pack( 'Cn' ), bytes ].join,
-        p1_sockaddr: nil,
-        rep2p: 0
+        wbuff: [ [ PAIRING ].pack( 'C' ), bytes ].join
       }
-      @room = room
-      @room_info = room_info
       @roles[ room ] = :room
       @infos[ room ] = room_info
       @reads << room
       @writes << room
+      @app_info[ :room ] = room
+      @app_info[ :updated_at ] = Time.new
     end
 
     def new_p2
       p2 = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
       p2.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
       p2.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
-      p2.bind( @room.local_address ) # use the hole
+      p2.bind( @app_info[ :room ].local_address ) # use the hole
 
       begin
-        p2.connect_nonblock( @room_info[ :p1_sockaddr ] )
+        p2.connect_nonblock( @app_info[ :p1_sockaddr ] )
       rescue IO::WaitWritable, Errno::EINTR
       rescue Exception => e
         puts "connect p1 #{ e.class } #{ Time.new }"
         p2.close
+        add_closing( @app_info[ :room ] )
         return
       end
 
@@ -420,10 +478,9 @@ module P2p2
         chunk_dir: @p2_chunk_dir,
         chunks: [],
         chunk_seed: 0,
-        need_decode: true
+        need_decode: true,
+        need_renew: false
       }
-      @p2 = p2
-      @p2_info = p2_info
       @roles[ p2 ] = :p2
       @infos[ p2 ] = p2_info
       @reads << p2
@@ -431,6 +488,8 @@ module P2p2
       unless p2_info[ :wbuff ].empty?
         @writes << p2
       end
+
+      @app_info[ :p2 ] = p2
     end
   end
 end

data/lib/p2p2/p2pd.rb

@@ -5,13 +5,24 @@ require 'socket'
 ##
 # P2p2::P2pd - 处于nat里的任意应用，访问处于另一个nat里的应用服务端，借助一根p2p管道。配对服务器端。
 #
-#```
-#              p2pd                              p2pd
-#             ^                                 ^
-#            ^                                 ^
-#  ssh --> p2 --> encode --> nat --> nat --> p1 --> decode --> sshd
+# 1.
 #
-#```
+# ```
+#                    p2pd
+#                    ^  ^
+#                  ^    ^
+#      “周立波的房间”     “周立波的房间”
+#      ^                         ^
+#     ^                         ^
+#   p1 --> nat --><-- nat <-- p2
+#
+# ```
+#
+# 2.
+#
+# ```
+#   ssh --> p2 --> (encode) --> p1 --> (decode) --> sshd
+# ```
 #
 # usage
 # =====
@@ -37,18 +48,24 @@ module P2p2
       @reads = []
       @writes = []
       @closings = []
-      @socks = {} # object_id => sock
-      @pending_p1s = {} # title => room
-      @pending_p2s = {} # title => room
       @roles = {} # sock => :roomd / :room
       @infos = {}
+      @rooms = {} # object_id => room
+      @p1s = {} # title => room
+      @p2s = {} # title => room
 
       ctlr, ctlw = IO.pipe
       @ctlw = ctlw
       @roles[ ctlr ] = :ctlr
       @reads << ctlr
 
-      new_roomd
+      roomd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      roomd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+      roomd.bind( Socket.pack_sockaddr_in( @roomd_port, '0.0.0.0' ) )
+      roomd.listen( 511 )
+
+      @roles[ roomd ] = :roomd
+      @reads << roomd
     end
 
     def looping
@@ -93,13 +110,13 @@ module P2p2
     def loop_expire
       Thread.new do
         loop do
-          sleep 900
+          sleep 3600
 
           if @infos.any?
             @mutex.synchronize do
               now = Time.new
 
-              @infos.select{ | _, info | now - info[ :updated_at ] > 1800 }.each do | room, _ |
+              @infos.select{ | _, info | now - info[ :updated_at ] > 86400 }.each do | room, _ |
                 @ctlw.write( [ CTL_CLOSE_ROOM, [ room.object_id ].pack( 'N' ) ].join )
               end
             end
@@ -108,11 +125,11 @@ module P2p2
       end
     end
 
-    def read_ctlr( sock )
-      case sock.read( 1 )
+    def read_ctlr( ctlr )
+      case ctlr.read( 1 )
       when CTL_CLOSE_ROOM
-        room_id = sock.read( 4 ).unpack( 'N' ).first
-        room = @socks[ room_id ]
+        room_id = ctlr.read( 4 ).unpack( 'N' ).first
+        room = @rooms[ room_id ]
 
         if room
           add_closing( room )
@@ -120,123 +137,109 @@ module P2p2
       end
     end
 
-    def read_roomd( sock )
+    def read_roomd( roomd )
       begin
-        room, addr = sock.accept_nonblock
+        room, addrinfo = roomd.accept_nonblock
       rescue IO::WaitReadable, Errno::EINTR
         return
       end
 
-      @socks[ room.object_id ] = room
+      @rooms[ room.object_id ] = room
       @roles[ room ] = :room
       @infos[ room ] = {
         title: nil,
         wbuff: '',
-        updated_at: Time.new,
-        sockaddr: addr.to_sockaddr
+        sockaddr: addrinfo.to_sockaddr,
+        updated_at: Time.new
       }
       @reads << room
     end
 
-    def read_room( sock )
+    def read_room( room )
       begin
-        data = sock.read_nonblock( PACK_SIZE )
+        data = room.read_nonblock( PACK_SIZE )
       rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
         return
       rescue Exception => e
-        add_closing( sock )
+        add_closing( room )
         return
       end
 
-      info = @infos[ sock ]
+      info = @infos[ room ]
       info[ :updated_at ] = Time.new
+      ctl_num = data[ 0 ].unpack( 'C' ).first
 
-      until data.empty?
-        ctl_num = data[ 0 ].unpack( 'C' ).first
+      case ctl_num
+      when SET_TITLE
+        title = data[ 1..-1 ]
 
-        case ctl_num
-        when HEARTBEAT
-          data = data[ 1..-1 ]
-        when SET_TITLE
-          len = data[ 1, 2 ].unpack( 'n' ).first
+        if title.size > 255
+          puts 'title too long'
+          add_closing( room )
+          return
+        end
 
-          if len > 255
-            puts "title too long"
-            add_closing( sock )
-            return
-          end
+        if @p1s.include?( title )
+          puts "p1 #{ title.inspect } already exist"
+          add_closing( room )
+          return
+        end
 
-          title = data[ 3, len ]
-
-          if @pending_p2s.include?( title )
-            p2 = @pending_p2s[ title ]
-            p2_info = @infos[ p2 ]
-            add_write( sock, p2_info[ :sockaddr ] )
-            add_write( p2, info[ :sockaddr ] )
-          elsif @pending_p1s.include?( title )
-            puts "pending p1 #{ title.inspect } already exist"
-            add_closing( sock )
-            return
-          else
-            @pending_p1s[ title ] = sock
-            info[ :title ] = title
-
-            begin
-              File.open( File.join( @roomd_dir, title ), 'w' )
-            rescue Errno::ENOENT, ArgumentError => e
-              puts "open title path #{ e.class }"
-              add_closing( sock )
-              return
-            end
-          end
+        if @p2s.include?( title )
+          p2 = @p2s[ title ]
+          p2_info = @infos[ p2 ]
+          add_write( room, p2_info[ :sockaddr ] )
+          add_write( p2, info[ :sockaddr ] )
+          return
+        end
 
-          data = data[ ( 3 + len )..-1 ]
-        when PAIRING
-          len = data[ 1, 2 ].unpack( 'n' ).first
+        begin
+          File.open( File.join( @roomd_dir, title ), 'w' )
+        rescue Errno::ENOENT, ArgumentError => e
+          puts "open title path #{ e.class }"
+          add_closing( room )
+          return
+        end
 
-          if len > 255
-            puts 'pairing title too long'
-            add_closing( sock )
-            return
-          end
+        info[ :title ] = title
+        @p1s[ title ] = room
+      when PAIRING
+        title = data[ 1..-1 ]
 
-          title = data[ 3, len ]
-
-          if @pending_p1s.include?( title )
-            p1 = @pending_p1s[ title ]
-            p1_info = @infos[ p1 ]
-            add_write( sock, p1_info[ :sockaddr ] )
-            add_write( p1, info[ :sockaddr ] )
-          elsif @pending_p2s.include?( title )
-            puts "pending p2 #{ title.inspect } already exist"
-            add_closing( sock )
-            return
-          else
-            @pending_p2s[ title ] = sock
-            info[ :title ] = title
-          end
+        if title.size > 255
+          puts 'pairing title too long'
+          add_closing( room )
+          return
+        end
 
-          data = data[ ( 3 + len )..-1 ]
+        if @p2s.include?( title )
+          puts "p2 #{ title.inspect } already exist"
+          add_closing( room )
+          return
         end
-      end
-    end
 
-    def write_room( sock )
-      if @closings.include?( sock )
-        close_sock( sock )
-        return
-      end
+        if @p1s.include?( title )
+          p1 = @p1s[ title ]
+          p1_info = @infos[ p1 ]
+          add_write( room, p1_info[ :sockaddr ] )
+          add_write( p1, info[ :sockaddr ] )
+          return
+        end
 
-      info = @infos[ sock ]
-      data = info[ :wbuff ]
+        info[ :title ] = title
+        @p2s[ title ] = room
+      end
+    end
 
-      if data.empty?
-        @writes.delete( sock )
+    def write_room( room )
+      if @closings.include?( room )
+        close_room( room )
         return
       end
 
-      sock.write( data )
-      info[ :wbuff ].clear
+      info = @infos[ room ]
+      room.write( info[ :wbuff ] )
+      @writes.delete( room )
     end
 
     def add_closing( sock )
@@ -251,7 +254,7 @@ module P2p2
     def add_write( sock, data = nil )
       if data
         info = @infos[ sock ]
-        info[ :wbuff ] << data
+        info[ :wbuff ] = data
       end
 
       unless @writes.include?( sock )
@@ -259,36 +262,25 @@ module P2p2
       end
     end
 
-    def close_sock( sock )
-      sock.close
-      @reads.delete( sock )
-      @writes.delete( sock )
-      @closings.delete( sock )
-      @socks.delete( sock.object_id )
-      @roles.delete( sock )
-      info = @infos.delete( sock )
+    def close_room( room )
+      room.close
+      @rooms.delete( room.object_id )
+      @reads.delete( room )
+      @writes.delete( room )
+      @closings.delete( room )
+      @roles.delete( room )
+      info = @infos.delete( room )
 
       if info && info[ :title ]
-        @pending_p1s.delete( info[ :title ] )
-        @pending_p2s.delete( info[ :title ] )
+        title_path = File.join( @roomd_dir, info[ :title ] )
 
-        begin
-          File.delete( File.join( @roomd_dir, info[ :title ] ) )
-        rescue Errno::ENOENT
+        if File.exist?( title_path )
+          File.delete( title_path )
+          @p1s.delete( info[ :title ] )
+        else
+          @p2s.delete( info[ :title ] )
         end
       end
-
-      info
-    end
-
-    def new_roomd
-      roomd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
-      roomd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
-      roomd.bind( Socket.pack_sockaddr_in( @roomd_port, '0.0.0.0' ) )
-      roomd.listen( 511 )
-
-      @roles[ roomd ] = :roomd
-      @reads << roomd
     end
   end
 end

data/lib/p2p2/version.rb

@@ -1,3 +1,3 @@
 module P2p2
-  VERSION = "0.6.7"
+  VERSION = "0.6.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: p2p2
 version: !ruby/object:Gem::Version
-  version: 0.6.7
+  version: 0.6.8
 platform: ruby
 authors:
 - takafan
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-06-20 00:00:00.000000000 Z
+date: 2019-07-11 00:00:00.000000000 Z
 dependencies: []
 description: 处于nat里的任意应用，访问处于另一个nat里的应用服务端，借助一根p2p管道。
 email: