public ConnectionHolder(Log log, HttpClientConnectionManager manager, HttpClientConnection
managedConn) : base()
{
this.log = log;
this.manager = manager;
this.managedConn = managedConn;
}
/// <summary>Sends the request and obtain a response.</summary>
/// <remarks>Sends the request and obtain a response.</remarks>
/// <param name="request">the request to execute.</param>
/// <param name="conn">the connection over which to execute the request.</param>
/// <returns>the response to the request.</returns>
/// <exception cref="System.IO.IOException">in case of an I/O error.</exception>
/// <exception cref="Org.Apache.Http.HttpException">
/// in case of HTTP protocol violation or a processing
/// problem.
/// </exception>
public virtual HttpResponse Execute(IHttpRequest request, HttpClientConnection conn
, HttpContext context)
{
Args.NotNull(request, "HTTP request");
Args.NotNull(conn, "Client connection");
Args.NotNull(context, "HTTP context");
try
{
HttpResponse response = DoSendRequest(request, conn, context);
if (response == null)
{
response = DoReceiveResponse(request, conn, context);
}
return(response);
}
catch (IOException ex)
{
CloseConnection(conn);
throw;
}
catch (HttpException ex)
{
CloseConnection(conn);
throw;
}
catch (RuntimeException ex)
{
CloseConnection(conn);
throw;
}
}
private void OnHttpRequestTimeout(object state)
{
try
{
HttpClientConnection clientConnection = (HttpClientConnection)state;
if (clientConnection == null)
{
return;
}
int actionId = 0;
string action;
if (clientConnection.Param.TryGetValue("ActionId", out action))
{
actionId = action.ToInt();
}
var httpresponse = new SocketGameResponse();
ActionFactory.RequestError(httpresponse, actionId, "Request Timeout.");
byte[] respData = httpresponse.ReadByte();
OnHttpResponse(clientConnection, respData, 0, respData.Length);
}
catch
{
}
}
/// <summary>
/// Implements chunked transfer encoding, as defined in §3.6.1 RFC 2616.
/// </summary>
/// <param name="Output">Decoded output.</param>
/// <param name="ChunkSize">Chunk size.</param>
/// <param name="ClientConnection">Client conncetion.</param>
internal ChunkedTransferEncoding(IBinaryTransmission Output, int ChunkSize, HttpClientConnection ClientConnection)
: base(Output, ClientConnection)
{
this.chunkSize = ChunkSize;
this.chunk = new byte[ChunkSize];
this.pos = 0;
}
internal WebSocket(WebSocketListener WebSocketListener, HttpRequest Request,
HttpResponse Response)
{
this.listener = WebSocketListener;
this.httpRequest = Request;
this.httpResponse = Response;
this.connection = Request.clientConnection;
}
/// <exception cref="System.IO.IOException"></exception>
public virtual void Upgrade(HttpClientConnection conn, HttpRoute route, HttpContext
context)
{
Args.NotNull(conn, "Connection");
Args.NotNull(route, "HTTP route");
Asserts.Check(conn == this.conn, "Connection not obtained from this manager");
this.connectionOperator.Upgrade(this.conn, route.GetTargetHost(), context);
}
public virtual void ReleaseConnection(HttpClientConnection conn, object state, long
keepalive, TimeUnit tunit)
{
lock (this)
{
Args.NotNull(conn, "Connection");
Asserts.Check(conn == this.conn, "Connection not obtained from this manager");
if (this.log.IsDebugEnabled())
{
this.log.Debug("Releasing connection " + conn);
}
if (this.shutdown)
{
ShutdownConnection();
return;
}
try
{
this.updated = Runtime.CurrentTimeMillis();
if (!this.conn.IsOpen())
{
this.conn = null;
this.route = null;
this.conn = null;
this.expiry = long.MaxValue;
}
else
{
this.state = state;
if (this.log.IsDebugEnabled())
{
string s;
if (keepalive > 0)
{
s = "for " + keepalive + " " + tunit;
}
else
{
s = "indefinitely";
}
this.log.Debug("Connection can be kept alive " + s);
}
if (keepalive > 0)
{
this.expiry = this.updated + tunit.ToMillis(keepalive);
}
else
{
this.expiry = long.MaxValue;
}
}
}
finally
{
this.leased = false;
}
}
}
/// <summary>Initializes an instance of the <see cref="ServiceChannelClient"/> class.</summary>
/// <param name="connection">The HTTP client connection.</param>
/// <exception cref="ArgumentNullException"><paramref name="connection"/> is <see langword="null"/>.</exception>
protected ServiceChannelClient(HttpClientConnection connection)
{
if (connection == null)
{
throw new ArgumentNullException(nameof(connection));
}
ClientConnection = connection;
}
/// <summary>Send the given request over the given connection.</summary>
/// <remarks>
/// Send the given request over the given connection.
/// <p>
/// This method also handles the expect-continue handshake if necessary.
/// If it does not have to handle an expect-continue handshake, it will
/// not use the connection for reading or anything else that depends on
/// data coming in over the connection.
/// </remarks>
/// <param name="request">
/// the request to send, already
/// <see cref="PreProcess(Org.Apache.Http.IHttpRequest, HttpProcessor, HttpContext)">preprocessed
/// </see>
/// </param>
/// <param name="conn">
/// the connection over which to send the request,
/// already established
/// </param>
/// <param name="context">the context for sending the request</param>
/// <returns>
/// a terminal response received as part of an expect-continue
/// handshake, or
/// <code>null</code> if the expect-continue handshake is not used
/// </returns>
/// <exception cref="System.IO.IOException">in case of an I/O error.</exception>
/// <exception cref="Org.Apache.Http.HttpException">
/// in case of HTTP protocol violation or a processing
/// problem.
/// </exception>
protected internal virtual HttpResponse DoSendRequest(IHttpRequest request, HttpClientConnection
conn, HttpContext context)
{
Args.NotNull(request, "HTTP request");
Args.NotNull(conn, "Client connection");
Args.NotNull(context, "HTTP context");
HttpResponse response = null;
context.SetAttribute(HttpCoreContext.HttpConnection, conn);
context.SetAttribute(HttpCoreContext.HttpReqSent, false);
conn.SendRequestHeader(request);
if (request is HttpEntityEnclosingRequest)
{
// Check for expect-continue handshake. We have to flush the
// headers and wait for an 100-continue response to handle it.
// If we get a different response, we must not send the entity.
bool sendentity = true;
ProtocolVersion ver = request.GetRequestLine().GetProtocolVersion();
if (((HttpEntityEnclosingRequest)request).ExpectContinue() && !ver.LessEquals(HttpVersion
.Http10))
{
conn.Flush();
// As suggested by RFC 2616 section 8.2.3, we don't wait for a
// 100-continue response forever. On timeout, send the entity.
if (conn.IsResponseAvailable(this.waitForContinue))
{
response = conn.ReceiveResponseHeader();
if (CanResponseHaveBody(request, response))
{
conn.ReceiveResponseEntity(response);
}
int status = response.GetStatusLine().GetStatusCode();
if (status < 200)
{
if (status != HttpStatus.ScContinue)
{
throw new ProtocolException("Unexpected response: " + response.GetStatusLine());
}
// discard 100-continue
response = null;
}
else
{
sendentity = false;
}
}
}
if (sendentity)
{
conn.SendRequestEntity((HttpEntityEnclosingRequest)request);
}
}
conn.Flush();
context.SetAttribute(HttpCoreContext.HttpReqSent, true);
return(response);
}
public static CPoolEntry GetPoolEntry(HttpClientConnection proxy)
{
CPoolEntry entry = GetHandler(proxy).GetPoolEntry();
if (entry == null)
{
throw new ConnectionShutdownException();
}
return(entry);
}
private static void CloseConnection(HttpClientConnection conn)
{
try
{
conn.Close();
}
catch (IOException)
{
}
}
public void Calling_Refresh_UsingHttpClientConnection_DoesNotThrow()
{
var settings = ElasticsearchConfiguration.Settings()
.EnableCompressedResponses(true);
var connection = new HttpClientConnection(settings);
var client = new ElasticClient(settings, connection: connection);
Assert.DoesNotThrow(() => client.Refresh());
Assert.DoesNotThrow(() => client.Get <ElasticsearchProject>(NestTestData.Data.First().Id));
Assert.DoesNotThrow(() => client.Ping());
}
/// <exception cref="System.Exception"></exception>
public virtual object Invoke(object proxy, MethodInfo method, object[] args)
{
if (method.Equals(CloseMethod))
{
Close();
return(null);
}
else
{
if (method.Equals(ShutdownMethod))
{
Shutdown();
return(null);
}
else
{
if (method.Equals(IsOpenMethod))
{
return(Sharpen.Extensions.ValueOf(IsOpen()));
}
else
{
if (method.Equals(IsStaleMethod))
{
return(Sharpen.Extensions.ValueOf(IsStale()));
}
else
{
HttpClientConnection conn = GetConnection();
if (conn == null)
{
throw new ConnectionShutdownException();
}
try
{
return(method.Invoke(conn, args));
}
catch (TargetInvocationException ex)
{
Exception cause = ex.InnerException;
if (cause != null)
{
throw cause;
}
else
{
throw;
}
}
}
}
}
}
}
/// <exception cref="System.IO.IOException"></exception>
public virtual void RouteComplete(HttpClientConnection managedConn, HttpRoute route
, HttpContext context)
{
Args.NotNull(managedConn, "Managed Connection");
Args.NotNull(route, "HTTP route");
lock (managedConn)
{
CPoolEntry entry = CPoolProxy.GetPoolEntry(managedConn);
entry.MarkRouteComplete();
}
}
private static Apache.Http.Impl.Conn.CPoolProxy GetHandler(HttpClientConnection proxy
)
{
InvocationHandler handler = Proxy.GetInvocationHandler(proxy);
if (!typeof(Apache.Http.Impl.Conn.CPoolProxy).IsInstanceOfType(handler))
{
throw new InvalidOperationException("Unexpected proxy handler class: " + handler);
}
return(typeof(Apache.Http.Impl.Conn.CPoolProxy).Cast(handler));
}
public virtual bool IsStale()
{
HttpClientConnection conn = GetConnection();
if (conn != null)
{
return(conn.IsStale());
}
else
{
return(true);
}
}
private SsrsDiscovery.ReportingService2010 CreateSsrsClient( )
{
//Get the underlying connection
var conn = new HttpClientConnection(m_connectionManager.AcquireConnection(null));
var proxy = new SsrsDiscovery.ReportingService2010()
{
Url = Path.Combine(m_connectionManager.ConnectionString, "ReportService2010.asmx").Replace('\\', '/'),
Credentials = conn.CreateCredentials()
};
return(proxy);
}
private SsrsDiscovery.ReportingService2010 CreateSsrsClient(GeneralViewNode node)
{
//Get the underlying connection
var cm = ConnectionService.GetConnections().GetConnection(node.HttpConnection);
var conn = new HttpClientConnection(cm.AcquireConnection(null));
var proxy = new SsrsDiscovery.ReportingService2010()
{
Url = Path.Combine(cm.ConnectionString, "ReportService2010.asmx").Replace('\\', '/'),
Credentials = conn.CreateCredentials()
};
return(proxy);
}
private void CreateTCPConnectionClick(object sender, EventArgs e)
{
this._tcpConnForm.ShowDialog();
if (this._tcpConnForm.IsSaved)
{
bool connected = this.ConnectTCP();
if (!connected)
{
ErrorBox.ShowDialog(string.Format("Cannot connect to {0}:{1}", this._tcpConnForm.Host, this._tcpConnForm.Port));
this._currentConnection = null;
}
this._resendTCP.Enabled = connected;
}
}
/// <exception cref="System.IO.IOException"></exception>
public virtual void Upgrade(HttpClientConnection managedConn, HttpRoute route, HttpContext
context)
{
Args.NotNull(managedConn, "Managed Connection");
Args.NotNull(route, "HTTP route");
ManagedHttpClientConnection conn;
lock (managedConn)
{
CPoolEntry entry = CPoolProxy.GetPoolEntry(managedConn);
conn = entry.GetConnection();
}
this.connectionOperator.Upgrade(conn, route.GetTargetHost(), context);
}
/// <summary>Creates a credentials object for the given connection.</summary>
/// <param name="source">The source.</param>
/// <returns>The credentials.</returns>
public static ICredentials CreateCredentials(this HttpClientConnection source)
{
if (source.UseServerCredentials)
{
return(CredentialCache.DefaultCredentials);
}
if (!String.IsNullOrWhiteSpace(source.ServerDomain))
{
return(new NetworkCredential(source.ServerUserName, source.GetServerPassword(), source.ServerDomain));
}
else
{
return(new NetworkCredential(source.ServerUserName, source.GetServerPassword()));
}
}
static Task <HttpClientConnection> InitHttp(ClientBootstrap client, TlsConnectionOptions tlsOptions)
{
var options = new HttpClientConnectionOptions();
options.ClientBootstrap = client;
options.TlsConnectionOptions = tlsOptions;
options.HostName = ctx.Uri.Host;
options.Port = (UInt16)ctx.Uri.Port;
options.ConnectionShutdown += OnConnectionShutdown;
if (ctx.ConnectTimeoutMs != 0)
{
var socketOptions = new SocketOptions();
socketOptions.ConnectTimeoutMs = ctx.ConnectTimeoutMs;
options.SocketOptions = socketOptions;
}
return(HttpClientConnection.NewConnection(options));
}
/// <summary>Creates a basic HTTP binding from an HTTP client connection.</summary>
/// <param name="source">The connection.</param>
/// <returns>The binding.</returns>
/// <remarks>
/// The binding uses default binding settings except as indicated below.
/// <list type="bullet">
/// <item>BypassProxyOnLocal = true</item>
/// </list>
/// <para />
/// The binding is configured to use transport security if HTTPS is specified otherwise it uses no security.
/// <para />
/// The binding is configured to use NTLM credentials if the connection is using a domain for credentials.
/// </remarks>
public static BasicHttpBinding CreateBasicHttpBinding(this HttpClientConnection source)
{
//source.UseSecureConnection isn't true when HTTPS is applied so parse this manually
var uri = new Uri(source.ServerURL);
var binding = uri.Scheme == "https" ? new BasicHttpBinding(BasicHttpSecurityMode.Transport) : new BasicHttpBinding(BasicHttpSecurityMode.None);
binding.BypassProxyOnLocal = true;
if (source.UseWindowsCredentials())
{
binding.Security.Transport.ClientCredentialType = HttpClientCredentialType.Ntlm;
//binding.Security.Mode = BasicHttpSecurityMode.TransportCredentialOnly;
}
;
return(binding);
}
public override void Start()
{
IsBusy = true;
_upStreamConnection = new HttpClientConnection(_forwardingHost, _forwardingPort, _isSecure);
if (_upStreamConnection.Connect())
{
base.Start();
}
else
{
HttpServerConsole.Instance.WriteLine(LogMessageType.Information,
"Could not establish connection to {0}:{1}",
_forwardingHost, _forwardingPort);
Close();
IsBusy = false;
}
}
private bool ConnectTCP()
{
bool connected = false;
if (this._currentConnection != null)
{
this._currentConnection.Close();
}
this._isReading = false;
int port;
if (int.TryParse(this._tcpConnForm.Port, out port))
{
this._currentConnection = new HttpClientConnection(this._tcpConnForm.Host, port, this._tcpConnForm.IsSecure);
connected = this._currentConnection.Connect();
}
return(connected);
}
public virtual void ReleaseConnection(HttpClientConnection managedConn, object state
, long keepalive, TimeUnit tunit)
{
Args.NotNull(managedConn, "Managed connection");
lock (managedConn)
{
CPoolEntry entry = CPoolProxy.Detach(managedConn);
if (entry == null)
{
return;
}
ManagedHttpClientConnection conn = entry.GetConnection();
try
{
if (conn.IsOpen())
{
entry.SetState(state);
entry.UpdateExpiry(keepalive, tunit != null ? tunit : TimeUnit.Milliseconds);
if (this.log.IsDebugEnabled())
{
string s;
if (keepalive > 0)
{
s = "for " + (double)keepalive / 1000 + " seconds";
}
else
{
s = "indefinitely";
}
this.log.Debug("Connection " + Format(entry) + " can be kept alive " + s);
}
}
}
finally
{
this.pool.Release(entry, conn.IsOpen() && entry.IsRouteComplete());
if (this.log.IsDebugEnabled())
{
this.log.Debug("Connection released: " + Format(entry) + FormatStats(entry.GetRoute
()));
}
}
}
}
private void OnHttpRequestTimeout(object state)
{
try
{
HttpClientConnection clientConnection = (HttpClientConnection)state;
if (clientConnection == null)
{
return;
}
var actionGetter = clientConnection.ActionGetter;
clientConnection.GameResponse.WriteError(actionGetter, Language.Instance.ErrorCode, "Request Timeout.");
byte[] respData = clientConnection.GameResponse.ReadByte();
OnHttpResponse(clientConnection, respData, 0, respData.Length);
}
catch (Exception ex)
{
TraceLog.WriteError("OnHttpRequestTimeout:{0}", ex);
}
}
/// <summary>Sets the client credentials on a WCF client.</summary>
/// <typeparam name="T">The service interface.</typeparam>
/// <param name="source">The client.</param>
/// <param name="connection">The HTTP connection.</param>
/// <remarks>
/// Both Windows and basic credentials are supported.
/// </remarks>
public static void SetClientCredentials <T> (this ClientBase <T> source, HttpClientConnection connection) where T : class
{
//Windows
if (connection.UseWindowsCredentials())
{
var creds = source.ClientCredentials.Windows;
creds.ClientCredential.UserName = connection.ServerUserName;
creds.ClientCredential.Password = connection.GetServerPassword();
creds.ClientCredential.Domain = connection.ServerDomain;
}
else if (!String.IsNullOrWhiteSpace(connection.ServerUserName))
{
var creds = source.ClientCredentials;
creds.UserName.UserName = connection.ServerUserName;
creds.UserName.Password = connection.GetServerPassword();
}
;
}
/// <exception cref="System.IO.IOException"></exception>
public virtual void Connect(HttpClientConnection conn, HttpRoute route, int connectTimeout
, HttpContext context)
{
Args.NotNull(conn, "Connection");
Args.NotNull(route, "HTTP route");
Asserts.Check(conn == this.conn, "Connection not obtained from this manager");
HttpHost host;
if (route.GetProxyHost() != null)
{
host = route.GetProxyHost();
}
else
{
host = route.GetTargetHost();
}
IPEndPoint localAddress = route.GetLocalSocketAddress();
this.connectionOperator.Connect(this.conn, host, localAddress, connectTimeout, this
.socketConfig, context);
}
static Task <StreamResult> InitStream(HttpClientConnection connection)
{
var headers = new List <HttpHeader>();
headers.Add(new HttpHeader("Host", ctx.Uri.Host));
HttpRequest request = new HttpRequest();
request.Method = ctx.Verb;
request.Uri = ctx.Uri.PathAndQuery;
request.Headers = headers.ToArray();
request.BodyStream = ctx.PayloadStream;
HttpResponseStreamHandler responseHandler = new HttpResponseStreamHandler();
responseHandler.IncomingHeaders += OnIncomingHeaders;
responseHandler.IncomingBody += OnIncomingBody;
responseHandler.StreamComplete += OnStreamComplete;
return(connection.MakeRequest(request, responseHandler));
}
private void OnHttpResponse(HttpClientConnection connection, byte[] data, int offset, int count)
{
try
{
connection.TimeoutTimer.Dispose();
HttpListenerResponse response = connection.Context.Response;
response.ContentType = "application/octet-stream";
if (data[offset] == 0x1f && data[offset + 1] == 0x8b && data[offset + 2] == 0x08 && data[offset + 3] == 0x00)
{
response.AddHeader("Content-Encoding", "gzip");
}
response.AddHeader("Access-Control-Allow-Origin", "*");
response.ContentLength64 = count;
Stream output = response.OutputStream;
output.Write(data, offset, count);
output.Close();
connection.Close();
}
catch
{
}
}
private void OnHttpRequest(IAsyncResult result)
{
try
{
HttpListener listener = (HttpListener)result.AsyncState;
HttpListenerContext context = listener.EndGetContext(result);
listener.BeginGetContext(OnHttpRequest, listener);
HttpListenerRequest request = context.Request;
HttpListenerResponse response = context.Response;
string sid = request.QueryString["sid"];
GameSession session;
if (string.IsNullOrEmpty(sid))
{
session = GameSession.CreateNew(Guid.NewGuid(), request);
}
else
{
session = GameSession.Get(sid) ?? GameSession.CreateNew(Guid.NewGuid(), request);
}
string data = "";
if (Environment.OSVersion.Platform == PlatformID.Unix)
{
if (string.Compare(request.HttpMethod, "get", true) == 0)
{
data = request.RawUrl.Substring(8);
data = HttpUtility.UrlDecode(data);
}
}
else
{
data = request.QueryString["d"];
}
if (string.IsNullOrEmpty(data))
{
using (var reader = new StreamReader(request.InputStream, request.ContentEncoding))
{
data = reader.ReadToEnd();
data = HttpUtility.ParseQueryString(data)["d"];
}
}
int statuscode = 0;
Dictionary<string, string> param = new Dictionary<string, string>(StringComparer.InvariantCultureIgnoreCase);
if (data != null)
{
var nvc = HttpUtility.ParseQueryString(data);
foreach (var key in nvc.AllKeys)
{
param[key] = nvc[key];
}
}
statuscode = CheckHttpParam(param);
if (statuscode != (int)HttpStatusCode.OK)
{
response.StatusCode = statuscode;
response.Close();
return;
}
var httpresponse = new SocketGameResponse();
httpresponse.WriteErrorCallback += new ActionDispatcher().ResponseError;
HttpGet httpGet = new HttpGet(new RequestPackage() { UrlParam = data, Session = session });
httpGet["UserHostAddress"] = session.EndAddress;
httpGet["ssid"] = session.KeyCode.ToString("N");
httpGet["http"] = "1";
var clientConnection = new HttpClientConnection {
Context = context,
Session = session,
ActionGetter = httpGet,
GameResponse = httpresponse
};
clientConnection.TimeoutTimer = new Timer(OnHttpRequestTimeout, clientConnection, httpRequestTimeout, Timeout.Infinite);
OnRequested(httpGet, httpresponse);
byte[] respData = httpresponse.ReadByte();
OnHttpResponse(clientConnection, respData, 0, respData.Length);
}
catch (Exception ex)
{
TraceLog.WriteError("OnHttpRequest error:{0}", ex);
}
}
private void OnHttpRequest(IAsyncResult result)
{
try
{
HttpListener listener = (HttpListener)result.AsyncState;
HttpListenerContext context = listener.EndGetContext(result);
listener.BeginGetContext(OnHttpRequest, listener);
RequestPackage package;
if (!ActionDispatcher.TryDecodePackage(context, out package))
{
return;
}
GameSession session;
if (package.ProxySid != Guid.Empty)
{
session = GameSession.Get(package.ProxySid) ?? GameSession.CreateNew(package.ProxySid, context.Request);
session.ProxySid = package.ProxySid;
}
else
{
session = (string.IsNullOrEmpty(package.SessionId)
? GameSession.GetSessionByCookie(context.Request)
: GameSession.Get(package.SessionId))
?? GameSession.CreateNew(Guid.NewGuid(), context.Request);
}
package.Bind(session);
ActionGetter httpGet = ActionDispatcher.GetActionGetter(package, session);
if (package.IsUrlParam)
{
httpGet["UserHostAddress"] = session.RemoteAddress;
httpGet["ssid"] = session.KeyCode.ToString("N");
httpGet["http"] = "1";
}
//set cookie
var cookie = context.Request.Cookies["sid"];
if (cookie == null)
{
cookie = new Cookie("sid", session.SessionId);
cookie.Expires = DateTime.Now.AddMinutes(5);
context.Response.SetCookie(cookie);
}
var httpresponse = new SocketGameResponse();
httpresponse.WriteErrorCallback += new ScutActionDispatcher().ResponseError;
var clientConnection = new HttpClientConnection
{
Context = context,
Session = session,
ActionGetter = httpGet,
GameResponse = httpresponse
};
var section = GetSection();
clientConnection.TimeoutTimer = new Timer(OnHttpRequestTimeout, clientConnection, section.HttpRequestTimeout, Timeout.Infinite);
byte[] respData = new byte[0];
if (!string.IsNullOrEmpty(package.RouteName))
{
if (CheckRemote(package.RouteName, httpGet))
{
MessageStructure response = new MessageStructure();
OnCallRemote(package.RouteName, httpGet, response);
respData = response.PopBuffer();
}
}
else
{
DoAction(httpGet, httpresponse);
respData = httpresponse.ReadByte();
}
OnHttpResponse(clientConnection, respData, 0, respData.Length);
}
catch (Exception ex)
{
TraceLog.WriteError("OnHttpRequest error:{0}", ex);
}
}
