bgpmanager/bgpmanager-impl/src/main/java/org/opendaylight/bgpmanager/thrift/server/implementation/BgpThriftService.java

   1 package org.opendaylight.bgpmanager.thrift.server.implementation;
   2
   3 import org.apache.thrift.server.THsHaServer;
   4 import org.apache.thrift.server.TServer;
   5 import org.apache.thrift.server.TSimpleServer;
   6 import org.apache.thrift.server.TThreadPoolServer;
   7 import org.apache.thrift.transport.*;
   8 import org.opendaylight.bgpmanager.thrift.common.Constants;
   9 import org.opendaylight.bgpmanager.thrift.gen.BgpUpdater;
  10 import org.slf4j.Logger;
  11 import org.slf4j.LoggerFactory;
  12
  13 public class BgpThriftService {
  14
  15         private static final Logger logger = LoggerFactory.getLogger(BgpThriftService.class);
  16
  17         private int port;
  18         //private int serverType;
  19         private int maxWorkerThreads;
  20         private int minWorkerThreads;
  21     private TServerTransport serverTransport;
  22         //private TNonblockingServerTransport serverTransport;
  23     private TServer server;
  24         private BgpUpdateHandler notificationHandler;
  25
  26     public BgpThriftService() {
  27
  28     }
  29
  30
  31         public void start() {
  32                 logger.info("BGP Thrift Server starting.");
  33                 startBgpThriftServer();
  34         }
  35
  36         public void stop() {
  37                 logger.info("BGP Thrift Server stopping.");
  38                 stopBgpThriftServer();
  39         }
  40
  41         /**
  42          * Destroy method called up after the bundle has been stopped
  43          */
  44         public void destroy() {
  45                 logger.debug("BGP Thrift Server destroy ");
  46         }
  47
  48     /**
  49      * Loading the parameters required for a connection
  50      *
  51      */
  52     private void loadParameters() {
  53         port = Integer.getInteger(Constants.PROP_BGP_THRIFT_PORT, Constants.BGP_SERVICE_PORT);
  54                 maxWorkerThreads = Integer.getInteger(Constants.PROP_MAX_WORKER_THREADS,
  55                         Constants.DEFAULT_MAX_WORKER_THREADS);
  56                 minWorkerThreads = Integer.getInteger(Constants.PROP_MIN_WORKER_THREADS,
  57                         Constants.DEFAULT_MIN_WORKER_THREADS);
  58
  59         }
  60
  61
  62         public void startBgpThriftServer() {
  63                 loadParameters();
  64                 new Thread(new ThriftRunnable()).start();
  65         }
  66
  67         public void stopBgpThriftServer() {
  68                 try {
  69             logger.debug("Server stopping");
  70
  71             if (serverTransport != null) {
  72                 serverTransport.close();
  73             }
  74
  75             server.stop();
  76         } catch (Exception e) {
  77             logger.error("Error while stopping the server - {} {}", getClass().getName(), e.getMessage());
  78         }
  79         }
  80
  81         private class ThriftRunnable implements Runnable {
  82                 @Override
  83                 public void run() {
  84                         notificationHandler = new BgpUpdateHandler();
  85
  86                 try {
  87                                 serverTransport = new TServerSocket(port);
  88                                 //serverTransport = new TNonblockingServerSocket(port);
  89                     logger.info("Server Socket on Port {} ", port);
  90                         } catch (TTransportException e) {
  91                                 e.printStackTrace();
  92                                 return;
  93                         }
  94                         /* This may need to change. Right now, its as good as a blocking server for each client (client would be
  95                         single - qbgp). We may want to change the server to TSimpleServer which queues up the notifications and
  96                         let worker threads process notifications based on rd.
  97                          */
  98                 server = new TThreadPoolServer(new TThreadPoolServer.Args(serverTransport)
  99                         .maxWorkerThreads(maxWorkerThreads).minWorkerThreads(minWorkerThreads)
 100                         .processor(new BgpUpdater.Processor<BgpUpdateHandler>(notificationHandler)));
 101                         /*
 102                         THsHaServer.Args args = new THsHaServer.Args(serverTransport);
 103                         args.workerThreads(10);
 104                         server = new THsHaServer(args.processor(new BgpUpdater.Processor<BgpUpdateHandler>(notificationHandler)));*/
 105
 106                         server.serve();
 107                 }
 108         }
 109
 110 }