接着第一篇工作,本篇继续分析种子文件监听服务器的实现细节。

先简单描述下其工作流程,首先服务器在6880端口处开启一个套接字监听,然后开启一个守护线程用于处理到来的打开种子文件列表请求,在这个服务线程中不断循环读取来自客户的请求,对torrent文件列表进行解析。如果此时Azureus的各个组件都已经创建完毕,则说明Azureus的核心处理组件可用,则直接对torrent文件列表进行处理,否则,先将torrent文件列表加入种子文件队列中,等到各个组件创建完毕后再来处理种子队列中的各个种子文件。

下面来查看其源代码,先看其成员变量:

  1. private ServerSocket socket;//服务器套接字  
  2.     private int state;//服务器当前状态  
  3.     private boolean bContinue;//服务线程是否继续运行  
  4.     public static final int STATE_FAULTY = 0;//错误状态  
  5.     public static final int STATE_LISTENING = 1;//监听状态  
  6.     protected List queued_torrents = new ArrayList();//待解析种子文件队列,这里并没有考虑同步互斥的问题  
  7. protected boolean core_started    = false;//核心处理组件是否已经启动  

在其构造函数中完成服务器的创建和启动:

  1. socket = new ServerSocket(688050, InetAddress.getByName("127.0.0.1")); //NOLAR: only bind to localhost  
  2.  
  3. state = STATE_LISTENING;//设置服务器状态为“监听”  

而在pollForConnections中为Azureus添加了一个生命周期监听器,这样当其所有组件完成时就会通知此监听器,而后者会调用openQueuedTorrents方法,对待解析种子文件队列中排队的种子文件进行处理,此外,这个方法中还创建了一个守护线程用于处理到来的打开种子文件列表请求,实际的处理工作在pollForConnectionsSupport方法中完成:

  1. public void pollForConnections(final AzureusCore azureus_core )  
  2.    {  
  3.        //增加生命周期监听者  
  4.        azureus_core.addLifecycleListener(new AzureusCoreLifecycleAdapter()  
  5.        {  
  6.            //所有组件创建完毕  
  7.            public void componentCreated(AzureusCore core, AzureusCoreComponent    component)   
  8.            {  
  9.                if ( component instanceof UIFunctionsSWT )  
  10.                {  
  11.                    openQueuedTorrents( azureus_core );//打开排队的种子文件列表  
  12.                }  
  13.            }  
  14.        });  
  15.          
  16.        if ( socket != null )  
  17.        {//开启一个守护线程用于处理到来的打开种子文件列表请求  
  18.            Thread t = new AEThread("Start Server")  
  19.            {  
  20.                //runSupport是一个abstract方法,在run中调用,是实际的线程函数  
  21.                public void runSupport()  
  22.                {  
  23.                    pollForConnectionsSupport( azureus_core );  
  24.                }  
  25.            };  
  26.            t.setDaemon(true);  
  27.            t.start(); //启动线程  
  28.        }  
  29.    } 

这里线程的中断采用设置运行标志的方式,我觉得这并不是一个很好的解决方案,因为若线程要完成的工作十分耗时,则线程的中断就不能立即见效。更好的办法应该是interrupt方法和中断标志混合起来使用。

  1. private void pollForConnectionsSupport(AzureusCore azureus_core)   
  2.   {  
  3.       bContinue = true;  
  4.       while (bContinue)   
  5.       {  
  6.           BufferedReader br = null;  
  7.           try   
  8.           {  
  9.               Socket sck = socket.accept();//接受一个连接请求  
  10.               String address = sck.getInetAddress().getHostAddress(); //绑定的本地IP地址  
  11.               if (address.equals("localhost") || address.equals("127.0.0.1"))   
  12.               {  
  13.                   br = new BufferedReader(new InputStreamReader(sck.getInputStream(),Constants.DEFAULT_ENCODING));  
  14.                   String line = br.readLine();//读取一行数据            
  15.                   if (Logger.isEnabled())  
  16.                         Logger.log(new LogEvent(LOGID, "Main::startServer: received '"+ line + "'"));  
  17.                   if (line != null)  
  18.                   {  
  19.                       String [] args = parseArgs(line);//解析请求数据  
  20.                       if (args != null && args.length > 0)   
  21.                       {  
  22.                           String debug_str = args[0];//第一行数据仅供测试使用,故抛弃不用  
  23.                           for (int i=1; i<args.length; i++)   
  24.                           {  
  25.                               debug_str += " ; " + args[i];  
  26.                           }  
  27.                           Logger.log(new LogEvent(LOGID, "Main::startServer: decoded to '" + debug_str + "'"));  
  28.                           processArgs(azureus_core,args); //处理解析出的种子文件列表  
  29.  
  30.                       }  
  31.                   }  
  32.               }  
  33.               sck.close();  
  34.           }  
  35.           catch (Exception e)   
  36.           {  
  37.               if(!(e instanceof SocketException))  
  38.                   Debug.printStackTrace( e );        
  39.           }  
  40.           finally   
  41.           {  
  42.               try   
  43.               {  
  44.                   if (br != null)  
  45.                       br.close();  
  46.               } catch (Exception e) { /*ignore */}  
  47.           }  
  48.       }  
  49.   } 

      在种子文件列表解析成功后,对其处理要分情况考虑,若处理核心还未启动,则将其加入种子队列中排队等待,否则直接对其解析处理。

 

  1. try   
  2.         {  
  3.             this_mon.enter();  
  4.  
  5.             if (!core_started)   
  6.             {//若核心还未启动,则进入种子队列中等待  
  7.                 queued_torrents.add( new Object[]{ file_name, new Boolean( open )});//加入种子文件队列中  
  8.                 queued = true;  
  9.             }  
  10.         }  
  11.         finally   
  12.         {  
  13.           this_mon.exit();  
  14.         }  
  15.         if ( !queued )  
  16.         {//无须排队,直接进行种子文件的解析处理  
  17.             handleFile( azureus_core, file_name, open );  
  18.         } 

     具体的处理工作由handleFile完成,其中调用了openTorrent方法来打开种子文件,具体的种子文件解析见第二文章

  1. protected void handleFile(AzureusCore    azureus_core,String file_name,boolean open )  
  2. {//处理种子文件  
  3.     try   
  4.     {  
  5.         if ( open )  
  6.         {  
  7.             TorrentOpener.openTorrent(file_name);//打开种子文件  
  8.               
  9.         }  
  10.         else 
  11.         {  
  12.             File    f = new File( file_name );  
  13.             if ( f.isDirectory())  
  14.             {  
  15.                 ShareUtils.shareDir( azureus_core, file_name );  
  16.                   
  17.             }  
  18.             else 
  19.             {  
  20.                ShareUtils.shareFile( azureus_core, file_name );                       
  21.             }  
  22.         }  
  23.     }   
  24.     catch (Throwable e)  
  25.     {  
  26.       Debug.printStackTrace(e);  
  27.     }  

   当Azureus生命周期来到各个组件都创建完毕时,会通知其监听者,从而调用 openQueuedTorrents方法来处理排队中的种子文件

  1. protected void openQueuedTorrents(AzureusCore azureus_core )  
  2.   {  
  3.       try 
  4.       {  
  5.           this_mon.enter();  
  6.           core_started    = true;//核心启动!  
  7.       }  
  8.       finally 
  9.       {  
  10.           this_mon.exit();  
  11.       }  
  12.            
  13.       //处理种子队列中的种子文件  
  14.       for (int i=0;i<queued_torrents.size();i++)  
  15.       {  
  16.           Object[]    entry = (Object[])queued_torrents.get(i);  
  17.           String    file_name     = (String)entry[0];//种子文件名  
  18.           boolean    open        = ((Boolean)entry[1]).booleanValue();//是否已经打开  
  19.           handleFile( azureus_core, file_name, open );  
  20.       }  
  21.   }