p2p2 0.5.9

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 382032ac70220ae3157ea62a6cb7e951b7e3ad641012f374494059eb79de1f28
+  data.tar.gz: 78ca2bce5ef38041fa0daffe65cd765692677463b1d5f5d850bbe1e6806f24b3
+SHA512:
+  metadata.gz: c4a6b9497f87eb5f47bc72cb6da0b4763d5aff974ab7fd24c7113a3ca7e80e8dd58e7c328ae174f73ccc13c013bbbd1ad2e20de513a3636b6536ff98123e2b4a
+  data.tar.gz: 886342bd2abc40eaa0a24aa215e37ae56b18051aee66bacbc3acec3a83c6291300f94c41a5ea5136210827ffbe787db7d19f4cbf74348f7a3d1e6327db85d0e8

data/lib/p2p2.rb

@@ -0,0 +1,6 @@
+require "p2p2/version"
+
+module P2p2
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/p2p2/head.rb

@@ -0,0 +1,10 @@
+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
+  NEED_RENEW = true
+end

data/lib/p2p2/hex.rb

@@ -0,0 +1,11 @@
+module P2p2
+  class Hex
+    def encode( data )
+      data
+    end
+
+    def decode( data )
+      data
+    end
+  end
+end

data/lib/p2p2/p1.rb

@@ -0,0 +1,397 @@
+require 'p2p2/head'
+require 'p2p2/hex'
+require 'p2p2/version'
+require 'socket'
+
+##
+# P2p2::P1 - 处于各自nat里的两端p2p。p1端。
+#
+module P2p2
+  class P1
+
+    ##
+    # roomd_host    匹配服务器ip
+    # roomd_port    匹配服务器端口
+    # appd_host     任意的一个应用的ip
+    # appd_port     应用端口
+    # 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 )
+      @title = title
+      @app_chunk_dir = app_chunk_dir
+      @p1_chunk_dir = p1_chunk_dir
+      @hex = P2p2::Hex.new
+      @mutex = Mutex.new
+      @roles = {}  # sock => :room / :p1 / :app
+      @infos = {}
+      @closings = {} # sock => need_renew
+      @reads = []
+      @writes = []
+      @is_renew = false
+
+      new_room
+    end
+
+    def looping
+      puts 'looping'
+
+      loop_heartbeat
+
+      loop do
+        rs, ws = IO.select( @reads, @writes )
+
+        @mutex.synchronize do
+          rs.each do | sock |
+            case @roles[ sock ]
+            when :room
+              read_room( sock )
+            when :p1
+              read_p1( sock )
+            when :app
+              read_app( sock )
+            end
+          end
+
+          ws.each do | sock |
+            case @roles[ sock ]
+            when :p1
+              write_p1( sock )
+            when :app
+              write_app( sock )
+            end
+          end
+        end
+      end
+    rescue Interrupt => e
+      puts e.class
+      quit!
+    end
+
+    def quit!
+      exit
+    end
+
+    private
+
+    def loop_heartbeat
+      Thread.new do
+        loop do
+          sleep 59
+
+          @mutex.synchronize do
+            @room.write( [ HEARTBEAT ].pack( 'C' ) )
+          end
+        end
+      end
+    end
+
+    def read_room( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue EOFError, Errno::ECONNRESET => e
+        puts "read room #{ e.class } #{ Time.new }"
+
+        if @is_renew
+          raise e
+        end
+
+        close_sock( @room )
+        sleep 5
+        new_room
+        @is_renew = true
+        return
+      end
+
+      @is_renew = false
+
+      if @p1
+        puts 'p1 already exist, ignore'
+        return
+      end
+
+      info = @infos[ sock ]
+      info[ :p2_sockaddr ] = data
+      new_p1
+    end
+
+    def read_p1( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue Errno::ECONNREFUSED => e
+        if @room_info[ :rep2p ] >= REP2P_LIMIT
+          raise e
+        end
+
+        add_closing( sock, NEED_RENEW )
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      unless @app
+        @room_info[ :rep2p ] = 0
+        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: '',
+          cache: '',
+          filename: [ Process.pid, app.object_id ].join( '-' ),
+          chunk_dir: @app_chunk_dir,
+          chunks: [],
+          chunk_seed: 0,
+          p1: sock,
+          need_encode: true
+        }
+
+        @app = app
+        @app_info = app_info
+        @roles[ app ] = :app
+        @infos[ app ] = app_info
+        @reads << app
+      end
+
+      info = @infos[ sock ]
+
+      if info[ :need_decode ]
+        len = data[ 0, 2 ].unpack( 'n' ).first
+        head = @hex.decode( data[ 2, len ] )
+        data = head + data[ ( 2 + len )..-1 ]
+        info[ :need_decode ] = false
+      end
+
+      add_write( @app, data, NEED_CHUNK )
+    end
+
+    def read_app( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+
+      if info[ :need_encode ]
+        data = @hex.encode( data )
+        data = [ [ data.size ].pack( 'n' ), data ].join
+        info[ :need_encode ] = false
+      end
+
+      add_write( @p1, data, NEED_CHUNK )
+    end
+
+    def write_p1( sock )
+      if @closings.include?( sock )
+        close_sock( sock )
+        @p1 = nil
+
+        if @app && !@app.closed?
+          add_closing( @app )
+        end
+
+        need_renew = @closings.delete( sock )
+
+        if need_renew
+          sleep 1
+          new_p1
+          @room_info[ :rep2p ] += 1
+        end
+
+        return
+      end
+
+      info = @infos[ sock ]
+      data, from = get_buff( info )
+
+      if data.empty?
+        @writes.delete( sock )
+        return
+      end
+
+      begin
+        written = sock.write_nonblock( data )
+      rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      data = data[ written..-1 ]
+      info[ from ] = data
+    end
+
+    def write_app( sock )
+      if @closings.include?( sock )
+        close_sock( sock )
+        @app = nil
+
+        if @p1 && !@p1.closed?
+          add_closing( @p1 )
+        end
+
+        @closings.delete( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+      data, from = get_buff( info )
+
+      if data.empty?
+        @writes.delete( sock )
+        return
+      end
+
+      begin
+        written = sock.write_nonblock( data )
+      rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      data = data[ written..-1 ]
+      info[ from ] = data
+    end
+
+    def get_buff( info )
+      data, from = info[ :cache ], :cache
+
+      if data.empty?
+        if info[ :chunks ].any?
+          path = File.join( info[ :chunk_dir ], info[ :chunks ].shift )
+          data = info[ :cache ] = IO.binread( path )
+
+          begin
+            File.delete( path )
+          rescue Errno::ENOENT
+          end
+        else
+          data, from = info[ :wbuff ], :wbuff
+        end
+      end
+
+      [ data, from ]
+    end
+
+    def add_closing( sock, need_renew = false )
+      unless @closings.include?( sock )
+        @closings[ sock ] = need_renew
+      end
+
+      add_write( sock )
+    end
+
+    def add_write( sock, data = nil, need_chunk = false )
+      if data
+        info = @infos[ sock ]
+        info[ :wbuff ] << data
+
+        if need_chunk && 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 ] )
+          info[ :chunks ] << filename
+          info[ :chunk_seed ] += 1
+          info[ :wbuff ].clear
+        end
+      end
+
+      unless @writes.include?( sock )
+        @writes << sock
+      end
+    end
+
+    def close_sock( sock )
+      sock.close
+      @roles.delete( sock )
+      @reads.delete( sock )
+      @writes.delete( sock )
+      info = @infos.delete( sock )
+
+      if info && info[ :chunks ]
+        info[ :chunks ].each do | filename |
+          begin
+            File.delete( File.join( info[ :chunk_dir ], filename ) )
+          rescue Errno::ENOENT
+          end
+        end
+      end
+
+      info
+    end
+
+    def new_room
+      room = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      room.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+      room.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
+
+      begin
+        room.connect_nonblock( @roomd_sockaddr )
+      rescue IO::WaitWritable, Errno::EINTR
+      end
+
+      room_info = {
+        p2_sockaddr: nil,
+        rep2p: 0
+      }
+      @room = room
+      @room_info = room_info
+      @roles[ room ] = :room
+      @infos[ room ] = room_info
+      @reads << room
+
+      bytes = @title.unpack( "C*" ).map{ | c | c.chr }.join
+      @room.write( [ [ SET_TITLE, bytes.size ].pack( 'Cn' ), bytes ].join )
+    end
+
+    def new_p1
+      p1 = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      p1.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+      p1.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
+      p1.bind( @room.local_address ) # use the hole
+
+      begin
+        p1.connect_nonblock( @room_info[ :p2_sockaddr ] )
+      rescue IO::WaitWritable, Errno::EINTR
+      rescue Exception => e
+        puts "connect p2 #{ e.class } #{ Time.new }"
+        p1.close
+        return
+      end
+
+      p1_info = {
+        wbuff: '',
+        cache: '',
+        filename: [ Process.pid, p1.object_id ].join( '-' ),
+        chunk_dir: @p1_chunk_dir,
+        chunks: [],
+        chunk_seed: 0,
+        need_decode: true
+      }
+      @p1 = p1
+      @p1_info = p1_info
+      @roles[ p1 ] = :p1
+      @infos[ p1 ] = p1_info
+      @reads << p1
+    end
+  end
+end

data/lib/p2p2/p2.rb

@@ -0,0 +1,423 @@
+require 'p2p2/head'
+require 'p2p2/hex'
+require 'p2p2/version'
+require 'socket'
+
+##
+# P2p2::P2 - 处于各自nat里的两端p2p。p2端。
+#
+module P2p2
+  class P2
+
+    ##
+    # roomd_host    匹配服务器ip
+    # roomd_port    匹配服务器端口
+    # appd_host     '0.0.0.0'，或者只允许本地访问：'127.0.0.1'
+    # appd_port     代理p1的应用端口
+    # 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 )
+      @title = title
+      @app_chunk_dir = app_chunk_dir
+      @p2_chunk_dir = p2_chunk_dir
+      @hex = P2p2::Hex.new
+      @mutex = Mutex.new
+      @roles = {}  # sock => :appd / :app / :room / :p2
+      @infos = {}
+      @closings = {} # sock => need_renew
+      @reads = []
+      @writes = []
+      @is_renew = false
+
+      new_appd
+    end
+
+    def looping
+      puts 'looping'
+
+      loop do
+        rs, ws = IO.select( @reads, @writes )
+
+        @mutex.synchronize do
+          rs.each do | sock |
+            case @roles[ sock ]
+            when :appd
+              read_appd( sock )
+            when :app
+              read_app( sock )
+            when :room
+              read_room( sock )
+            when :p2
+              read_p2( sock )
+            end
+          end
+
+          ws.each do | sock |
+            case @roles[ sock ]
+            when :p2
+              write_p2( sock )
+            when :app
+              write_app( sock )
+            end
+          end
+        end
+      end
+    rescue Interrupt => e
+      puts e.class
+      quit!
+    end
+
+    def quit!
+      exit
+    end
+
+    private
+
+    def loop_heartbeat
+      Thread.new do
+        loop do
+          sleep 59
+
+          @mutex.synchronize do
+            if @room
+              @room.write( [ HEARTBEAT ].pack( 'C' ) )
+            end
+          end
+        end
+      end
+    end
+
+    def read_appd( sock )
+      begin
+        app, addr = sock.accept_nonblock
+      rescue IO::WaitReadable, Errno::EINTR
+        return
+      end
+
+      if @app && !@app.closed?
+        puts "app already exist, ignore"
+        app.close
+        return
+      end
+
+      app_info = {
+        wbuff: '',
+        cache: '',
+        filename: [ Process.pid, app.object_id ].join( '-' ),
+        chunk_dir: @app_chunk_dir,
+        chunks: [],
+        chunk_seed: 0,
+        need_encode: true,
+        rbuff: ''
+      }
+      @app = app
+      @app_info = app_info
+      @roles[ app ] = :app
+      @infos[ app ] = app_info
+      @reads << app
+
+      new_room
+    end
+
+    def read_app( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+
+      if info[ :need_encode ]
+        data = @hex.encode( data )
+        data = [ [ data.size ].pack( 'n' ), data ].join
+        info[ :need_encode ] = false
+      end
+
+      if @p2
+        add_write( @p2, data, NEED_CHUNK )
+      else
+        info[ :rbuff ] << data
+      end
+    end
+
+    def read_room( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue EOFError, Errno::ECONNRESET => e
+        puts "read room #{ e.class } #{ Time.new }"
+
+        if @is_renew
+          raise e
+        end
+
+        close_sock( @room )
+        sleep 5
+        new_room
+        @is_renew = true
+        return
+      end
+
+      @is_renew = false
+
+      if @p2
+        puts 'p2 already exist, ignore'
+        return
+      end
+
+      info = @infos[ sock ]
+      info[ :p1_sockaddr ] = data
+      new_p2
+    end
+
+    def read_p2( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable => e
+        return
+      rescue Errno::ECONNREFUSED => e
+        if @room_info[ :rep2p ] >= REP2P_LIMIT
+          raise e
+        end
+
+        add_closing( sock, NEED_RENEW )
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+
+      if info[ :need_decode ]
+        len = data[ 0, 2 ].unpack( 'n' ).first
+        head = @hex.decode( data[ 2, len ] )
+        data = head + data[ ( 2 + len )..-1 ]
+        info[ :need_decode ] = false
+      end
+
+      add_write( @app, data, NEED_CHUNK )
+    end
+
+    def write_p2( sock )
+      if @closings.include?( sock )
+        close_sock( sock )
+        @p2 = nil
+
+        if @app && !@app.closed?
+          add_closing( @app )
+        end
+
+        need_renew = @closings.delete( sock )
+
+        if need_renew
+          sleep 1
+          new_p2
+          @room_info[ :rep2p ] += 1
+        end
+
+        return
+      end
+
+      info = @infos[ sock ]
+      data, from = get_buff( info )
+
+      if data.empty?
+        @writes.delete( sock )
+        return
+      end
+
+      begin
+        written = sock.write_nonblock( data )
+      rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      data = data[ written..-1 ]
+      info[ from ] = data
+    end
+
+    def write_app( sock )
+      if @closings.include?( sock )
+        close_sock( sock )
+        @app = nil
+
+        if @p2 && !@p2.closed?
+          add_closing( @p2 )
+        end
+
+        @closings.delete( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+      data, from = get_buff( info )
+
+      if data.empty?
+        @writes.delete( sock )
+        return
+      end
+
+      begin
+        written = sock.write_nonblock( data )
+      rescue IO::WaitWritable, Errno::EINTR, IO::WaitReadable
+        return
+      rescue Exception => e
+        add_closing( sock )
+        return
+      end
+
+      data = data[ written..-1 ]
+      info[ from ] = data
+    end
+
+    def get_buff( info )
+      data, from = info[ :cache ], :cache
+
+      if data.empty?
+        if info[ :chunks ].any?
+          path = File.join( info[ :chunk_dir ], info[ :chunks ].shift )
+          data = info[ :cache ] = IO.binread( path )
+
+          begin
+            File.delete( path )
+          rescue Errno::ENOENT
+          end
+        else
+          data, from = info[ :wbuff ], :wbuff
+        end
+      end
+
+      [ data, from ]
+    end
+
+    def add_closing( sock, need_renew = false )
+      unless @closings.include?( sock )
+        @closings[ sock ] = need_renew
+      end
+
+      add_write( sock )
+    end
+
+    def add_write( sock, data = nil, need_chunk = false )
+      if data
+        info = @infos[ sock ]
+        info[ :wbuff ] << data
+
+        if need_chunk && 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 ] )
+          info[ :chunks ] << filename
+          info[ :chunk_seed ] += 1
+          info[ :wbuff ].clear
+        end
+      end
+
+      unless @writes.include?( sock )
+        @writes << sock
+      end
+    end
+
+    def close_sock( sock )
+      sock.close
+      @roles.delete( sock )
+      @reads.delete( sock )
+      @writes.delete( sock )
+      info = @infos.delete( sock )
+
+      if info && info[ :chunks ]
+        info[ :chunks ].each do | filename |
+          begin
+            File.delete( File.join( info[ :chunk_dir ], filename ) )
+          rescue Errno::ENOENT
+          end
+        end
+      end
+
+      info
+    end
+
+    def new_appd
+      appd = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      appd.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+      appd.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
+      appd.bind( @appd_sockaddr )
+      appd.listen( 511 )
+
+      @appd = appd
+      @roles[ appd ] = :appd
+      @reads << appd
+    end
+
+    def new_room
+      room = Socket.new( Socket::AF_INET, Socket::SOCK_STREAM, 0 )
+      room.setsockopt( Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1 )
+      room.setsockopt( Socket::SOL_TCP, Socket::TCP_NODELAY, 1 )
+
+      begin
+        room.connect_nonblock( @roomd_sockaddr )
+      rescue IO::WaitWritable, Errno::EINTR
+      end
+
+      room_info = {
+        p1_sockaddr: nil,
+        rep2p: 0
+      }
+      @room = room
+      @room_info = room_info
+      @roles[ room ] = :room
+      @infos[ room ] = room_info
+      @reads << room
+
+      bytes = @title.unpack( "C*" ).map{ | c | c.chr }.join
+      @room.write( [ [ PAIRING, bytes.size ].pack( 'Cn' ), bytes ].join )
+    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
+
+      begin
+        p2.connect_nonblock( @room_info[ :p1_sockaddr ] )
+      rescue IO::WaitWritable, Errno::EINTR
+      rescue Exception => e
+        puts "connect p1 #{ e.class } #{ Time.new }"
+        p2.close
+        return
+      end
+
+      p2_info = {
+        wbuff: @app_info[ :rbuff ],
+        cache: '',
+        filename: [ Process.pid, p2.object_id ].join( '-' ),
+        chunk_dir: @p2_chunk_dir,
+        chunks: [],
+        chunk_seed: 0,
+        need_decode: true
+      }
+      @p2 = p2
+      @p2_info = p2_info
+      @roles[ p2 ] = :p2
+      @infos[ p2 ] = p2_info
+      @reads << p2
+
+      unless p2_info[ :wbuff ].empty?
+        @writes << p2
+      end
+    end
+  end
+end

data/lib/p2p2/p2pd.rb

@@ -0,0 +1,222 @@
+require 'p2p2/head'
+require 'p2p2/version'
+require 'socket'
+
+##
+# P2p2::P2pd - 处于各自nat里的两端p2p。匹配服务器端。
+#
+#```
+#              p2pd                              p2pd
+#             ^                                 ^
+#            ^                                 ^
+#  ssh --> p2 --> encode --> nat --> nat --> p1 --> decode --> sshd
+#
+#```
+#
+# usage
+# =====
+#
+# 1. Girl::P2pd.new( 5050 ).looping # @server
+#
+# 2. Girl::P1.new( 'your.server.ip', 5050, '127.0.0.1', 22, '周立波' ).looping # @home1
+#
+# 3. Girl::P2.new( 'your.server.ip', 5050, '0.0.0.0', 2222, '周立波' ).looping # @home2
+#
+# 4. ssh -p2222 libo@localhost
+#
+module P2p2
+  class P2pd
+
+    ##
+    # roomd_port    配对服务器端口
+    # roomd_dir     可在该目录下看到所有的p1
+    def initialize( roomd_port = 5050, roomd_dir = '/tmp' )
+      @roomd_port = roomd_port
+      @roomd_dir = roomd_dir
+      @mutex = Mutex.new
+      @roles = {} # sock => :roomd / :room
+      @pending_p1s = {} # title => room
+      @pending_p2s = {} # title => room
+      @infos = {}
+      @reads = []
+
+      new_roomd
+    end
+
+    def looping
+      puts 'looping'
+
+      loop_expire
+
+      loop do
+        rs, _ = IO.select( @reads )
+
+        @mutex.synchronize do
+          rs.each do | sock |
+            case @roles[ sock ]
+            when :roomd
+              read_roomd( sock )
+            when :room
+              read_room( sock )
+            end
+          end
+        end
+      end
+    rescue Interrupt => e
+      puts e.class
+      quit!
+    end
+
+    def quit!
+      exit
+    end
+
+    private
+
+    def loop_expire
+      Thread.new do
+        loop do
+          sleep 900
+
+          if @infos.any?
+            @mutex.synchronize do
+              now = Time.new
+
+              @infos.select{ | _, info | info[ :last_coming_at ] && ( now - info[ :last_coming_at ] > 1800 ) }.each do | room, _ |
+                close_sock( room )
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def read_roomd( sock )
+      begin
+        room, addr = sock.accept_nonblock
+      rescue IO::WaitReadable, Errno::EINTR
+        return
+      end
+
+      @roles[ room ] = :room
+      @infos[ room ] = {
+        title: nil,
+        last_coming_at: nil,
+        sockaddr: addr.to_sockaddr
+      }
+      @reads << room
+    end
+
+    def read_room( sock )
+      begin
+        data = sock.read_nonblock( PACK_SIZE )
+      rescue IO::WaitReadable, Errno::EINTR, IO::WaitWritable
+        return
+      rescue Exception => e
+        close_sock( sock )
+        return
+      end
+
+      info = @infos[ sock ]
+      info[ :last_coming_at ] = Time.new
+
+      until data.empty?
+        ctl_num = data[ 0 ].unpack( 'C' ).first
+
+        case ctl_num
+        when HEARTBEAT
+          data = data[ 1..-1 ]
+        when SET_TITLE
+          len = data[ 1, 2 ].unpack( 'n' ).first
+
+          if len > 255
+            puts "title too long"
+            close_sock( sock )
+            return
+          end
+
+          title = data[ 3, len ]
+
+          if @pending_p2s.include?( title )
+            p2 = @pending_p2s[ title ]
+            p2_info = @infos[ p2 ]
+            sock.write( p2_info[ :sockaddr ] )
+            p2.write( info[ :sockaddr ] )
+          elsif @pending_p1s.include?( title )
+            puts "pending p1 #{ title.inspect } already exist"
+            close_sock( 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 }"
+              close_sock( sock )
+              return
+            end
+          end
+
+          data = data[ ( 3 + len )..-1 ]
+        when PAIRING
+          len = data[ 1, 2 ].unpack( 'n' ).first
+
+          if len > 255
+            puts 'pairing title too long'
+            close_sock( sock )
+            return
+          end
+
+          title = data[ 3, len ]
+
+          if @pending_p1s.include?( title )
+            p1 = @pending_p1s[ title ]
+            p1_info = @infos[ p1 ]
+            sock.write( p1_info[ :sockaddr ] )
+            p1.write( info[ :sockaddr ] )
+          elsif @pending_p2s.include?( title )
+            puts "pending p2 #{ title.inspect } already exist"
+            close_sock( sock )
+            return
+          else
+            @pending_p2s[ title ] = sock
+            info[ :title ] = title
+          end
+
+          data = data[ ( 3 + len )..-1 ]
+        end
+      end
+    end
+
+    def close_sock( sock )
+      sock.close
+      @roles.delete( sock )
+      @reads.delete( sock )
+      info = @infos.delete( sock )
+
+      if info && info[ :title ]
+        @pending_p1s.delete( info[ :title ] )
+        @pending_p2s.delete( info[ :title ] )
+
+        begin
+          File.delete( File.join( @roomd_dir, info[ :title ] ) )
+        rescue Errno::ENOENT
+        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

@@ -0,0 +1,3 @@
+module P2p2
+  VERSION = "0.5.9"
+end

data/p2p2.gemspec

@@ -0,0 +1,29 @@
+
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "p2p2/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "p2p2"
+  spec.version       = P2p2::VERSION
+  spec.authors       = ["takafan"]
+  spec.email         = ["qqtakafan@gmail.com"]
+
+  spec.summary       = %q{p2p}
+  spec.description   = %q{p2p even both sides under its nat.}
+  spec.homepage      = "https://github.com/takafan/p2p2"
+  spec.license       = "MIT"
+
+  spec.files         = %w[
+p2p2.gemspec
+lib/p2p2.rb
+lib/p2p2/head.rb
+lib/p2p2/hex.rb
+lib/p2p2/p1.rb
+lib/p2p2/p2.rb
+lib/p2p2/p2pd.rb
+lib/p2p2/version.rb
+  ]
+
+  spec.require_paths = ["lib"]
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: p2p2
+version: !ruby/object:Gem::Version
+  version: 0.5.9
+platform: ruby
+authors:
+- takafan
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-06-19 00:00:00.000000000 Z
+dependencies: []
+description: p2p even both sides under its nat.
+email:
+- qqtakafan@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/p2p2.rb
+- lib/p2p2/head.rb
+- lib/p2p2/hex.rb
+- lib/p2p2/p1.rb
+- lib/p2p2/p2.rb
+- lib/p2p2/p2pd.rb
+- lib/p2p2/version.rb
+- p2p2.gemspec
+homepage: https://github.com/takafan/p2p2
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: p2p
+test_files: []