ceph/src/jaegertracing/thrift/lib/netcore/Thrift/Transports/Server/TServerSocketTransport.cs

   1 // Licensed to the Apache Software Foundation(ASF) under one
   2 // or more contributor license agreements.See the NOTICE file
   3 // distributed with this work for additional information
   4 // regarding copyright ownership.The ASF licenses this file
   5 // to you under the Apache License, Version 2.0 (the
   6 // "License"); you may not use this file except in compliance
   7 // with the License. You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing,
  12 // software distributed under the License is distributed on an
  13 // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
  14 // KIND, either express or implied. See the License for the
  15 // specific language governing permissions and limitations
  16 // under the License.
  17
  18 using System;
  19 using System.Net;
  20 using System.Net.Sockets;
  21 using System.Threading;
  22 using System.Threading.Tasks;
  23 using Thrift.Transports.Client;
  24
  25 namespace Thrift.Transports.Server
  26 {
  27     // ReSharper disable once InconsistentNaming
  28     public class TServerSocketTransport : TServerTransport
  29     {
  30         private readonly int _clientTimeout;
  31         private readonly int _port;
  32         private readonly bool _useBufferedSockets;
  33         private readonly bool _useFramedTransport;
  34         private TcpListener _server;
  35
  36         public TServerSocketTransport(TcpListener listener)
  37             : this(listener, 0)
  38         {
  39         }
  40
  41         public TServerSocketTransport(TcpListener listener, int clientTimeout)
  42         {
  43             _server = listener;
  44             _clientTimeout = clientTimeout;
  45         }
  46
  47         public TServerSocketTransport(int port)
  48             : this(port, 0)
  49         {
  50         }
  51
  52         public TServerSocketTransport(int port, int clientTimeout)
  53             : this(port, clientTimeout, false)
  54         {
  55         }
  56
  57         public TServerSocketTransport(int port, int clientTimeout, bool useBufferedSockets):
  58             this(port, clientTimeout, useBufferedSockets, false)
  59         {
  60         }
  61
  62         public TServerSocketTransport(int port, int clientTimeout, bool useBufferedSockets, bool useFramedTransport)
  63         {
  64             _port = port;
  65             _clientTimeout = clientTimeout;
  66             _useBufferedSockets = useBufferedSockets;
  67             _useFramedTransport = useFramedTransport;
  68             try
  69             {
  70                 // Make server socket
  71                 _server = new TcpListener(IPAddress.Any, _port);
  72                 _server.Server.NoDelay = true;
  73             }
  74             catch (Exception)
  75             {
  76                 _server = null;
  77                 throw new TTransportException("Could not create ServerSocket on port " + port + ".");
  78             }
  79         }
  80
  81         public override void Listen()
  82         {
  83             // Make sure not to block on accept
  84             if (_server != null)
  85             {
  86                 try
  87                 {
  88                     _server.Start();
  89                 }
  90                 catch (SocketException sx)
  91                 {
  92                     throw new TTransportException("Could not accept on listening socket: " + sx.Message);
  93                 }
  94             }
  95         }
  96
  97         public override bool IsClientPending()
  98         {
  99             return _server.Pending();
 100         }
 101
 102         protected override async Task<TClientTransport> AcceptImplementationAsync(CancellationToken cancellationToken)
 103         {
 104             if (cancellationToken.IsCancellationRequested)
 105             {
 106                 return await Task.FromCanceled<TClientTransport>(cancellationToken);
 107             }
 108
 109             if (_server == null)
 110             {
 111                 throw new TTransportException(TTransportException.ExceptionType.NotOpen, "No underlying server socket.");
 112             }
 113
 114             try
 115             {
 116                 TClientTransport tSocketTransport = null;
 117                 var tcpClient = await _server.AcceptTcpClientAsync();
 118
 119                 try
 120                 {
 121                     tSocketTransport = new TSocketClientTransport(tcpClient)
 122                     {
 123                         Timeout = _clientTimeout
 124                     };
 125
 126                     if (_useBufferedSockets)
 127                     {
 128                         tSocketTransport = new TBufferedClientTransport(tSocketTransport);
 129                     }
 130
 131                     if (_useFramedTransport)
 132                     {
 133                         tSocketTransport = new TFramedClientTransport(tSocketTransport);
 134                     }
 135
 136                     return tSocketTransport;
 137                 }
 138                 catch (Exception)
 139                 {
 140                     if (tSocketTransport != null)
 141                     {
 142                         tSocketTransport.Dispose();
 143                     }
 144                     else //  Otherwise, clean it up ourselves.
 145                     {
 146                         ((IDisposable) tcpClient).Dispose();
 147                     }
 148
 149                     throw;
 150                 }
 151             }
 152             catch (Exception ex)
 153             {
 154                 throw new TTransportException(ex.ToString());
 155             }
 156         }
 157
 158         public override void Close()
 159         {
 160             if (_server != null)
 161             {
 162                 try
 163                 {
 164                     _server.Stop();
 165                 }
 166                 catch (Exception ex)
 167                 {
 168                     throw new TTransportException("WARNING: Could not close server socket: " + ex);
 169                 }
 170                 _server = null;
 171             }
 172         }
 173     }
 174 }