| public static UploadDataAsync ( Uri address, X509Certificate2 clientCert, string contentType, byte data, int millisecondsTimeout, OpenWriteEventHandler openWriteCallback, DownloadProgressEventHandler downloadProgressCallback, RequestCompletedEventHandler completedCallback ) : HttpWebRequest | ||
| address | Uri | |
| clientCert | X509Certificate2 | |
| contentType | string | |
| data | byte | |
| millisecondsTimeout | int | |
| openWriteCallback | OpenWriteEventHandler | |
| downloadProgressCallback | DownloadProgressEventHandler | |
| completedCallback | RequestCompletedEventHandler | |
| return | HttpWebRequest | |
public void BeginGetResponse(byte[] postData, string contentType, int millisecondsTimeout)
{
_PostData = postData;
_ContentType = contentType;
if (_Request != null)
{
_Request.Abort();
_Request = null;
}
if (postData == null)
{
// GET
//Logger.Log.Debug("[CapsClient] GET " + _Address);
_Request = CapsBase.DownloadStringAsync(_Address, _ClientCert, millisecondsTimeout, DownloadProgressHandler,
RequestCompletedHandler);
}
else
{
// POST
//Logger.Log.Debug("[CapsClient] POST (" + postData.Length + " bytes) " + _Address);
_Request = CapsBase.UploadDataAsync(_Address, _ClientCert, contentType, postData, millisecondsTimeout, null,
DownloadProgressHandler, RequestCompletedHandler);
}
}
public void Start()
{
_Dead = false;
// Create an EventQueueGet request
OSDMap request = new OSDMap {
["ack"] = new OSD(), ["done"] = OSD.FromBoolean(false)
};
byte[] postData = OSDParser.SerializeLLSDXmlBytes(request);
_Request = CapsBase.UploadDataAsync(_Address, null, REQUEST_CONTENT_TYPE, postData, REQUEST_TIMEOUT, OpenWriteHandler, null, RequestCompletedHandler);
}
private void Client_OpenWriteCompleted(object sender, CapsBase.OpenWriteCompletedEventArgs e)
{
bool raiseEvent = false;
if (!_Dead)
{
if (!_Running)
{
raiseEvent = true;
}
// We are connected to the event queue
_Running = true;
}
// Create an EventQueueGet request
OSDMap request = new OSDMap();
request["ack"] = new OSD();
request["done"] = OSD.FromBoolean(false);
byte[] postData = OSDParser.SerializeLLSDXmlBytes(request);
_Client.UploadDataAsync(_Client.Location, postData);
if (raiseEvent)
{
Logger.Log.Debug("Capabilities event queue connected");
// The event queue is starting up for the first time
if (OnConnected != null)
{
try { OnConnected(); }
catch (Exception ex) { Logger.Log.Error(ex.Message, ex); }
}
}
}
public void StartRequest(byte[] postData, string contentType)
{
_PostData = postData;
_ContentType = contentType;
if (_Client.IsBusy)
{
_Client.CancelAsync();
}
_Client.Headers.Clear();
// Proxy
if (Proxy != null)
{
_Client.Proxy = Proxy;
}
// Content-Type
if (!String.IsNullOrEmpty(contentType))
{
_Client.Headers.Add(HttpRequestHeader.ContentType, contentType);
}
else
{
_Client.Headers.Add(HttpRequestHeader.ContentType, "application/xml");
}
if (postData == null)
{
_Client.DownloadStringAsync(_Client.Location);
}
else
{
_Client.UploadDataAsync(_Client.Location, postData);
}
}
void RequestCompletedHandler(HttpWebRequest request, HttpWebResponse response, byte[] responseData, Exception error)
{
// We don't care about this request now that it has completed
_Request = null;
OSDArray events = null;
int ack = 0;
if (responseData != null)
{
_errorCount = 0;
// Got a response
OSDMap result = OSDParser.DeserializeLLSDXml(responseData) as OSDMap;
if (result != null)
{
events = result["events"] as OSDArray;
ack = result["id"].AsInteger();
}
else
{
Logger.Log("Got an unparseable response from the event queue: \"" +
System.Text.Encoding.UTF8.GetString(responseData) + "\"", Helpers.LogLevel.Warning);
}
}
else if (error != null)
{
#region Error handling
HttpStatusCode code = HttpStatusCode.OK;
if (error is WebException)
{
WebException webException = (WebException)error;
if (webException.Response != null)
{
code = ((HttpWebResponse)webException.Response).StatusCode;
}
else if (webException.Status == WebExceptionStatus.RequestCanceled)
{
goto HandlingDone;
}
}
if (error is WebException && ((WebException)error).Response != null)
{
code = ((HttpWebResponse)((WebException)error).Response).StatusCode;
}
if (code == HttpStatusCode.NotFound || code == HttpStatusCode.Gone)
{
Logger.Log(String.Format("Closing event queue at {0} due to missing caps URI", _Address), Helpers.LogLevel.Info);
_Running = false;
_Dead = true;
}
else if (code == HttpStatusCode.BadGateway)
{
// This is not good (server) protocol design, but it's normal.
// The EventQueue server is a proxy that connects to a Squid
// cache which will time out periodically. The EventQueue server
// interprets this as a generic error and returns a 502 to us
// that we ignore
}
else
{
++_errorCount;
// Try to log a meaningful error message
if (code != HttpStatusCode.OK)
{
Logger.Log(String.Format("Unrecognized caps connection problem from {0}: {1}",
_Address, code), Helpers.LogLevel.Warning);
}
else if (error.InnerException != null)
{
Logger.Log(String.Format("Unrecognized internal caps exception from {0}: {1}",
_Address, error.InnerException.Message), Helpers.LogLevel.Warning);
}
else
{
Logger.Log(String.Format("Unrecognized caps exception from {0}: {1}",
_Address, error.Message), Helpers.LogLevel.Warning);
}
}
#endregion Error handling
}
else
{
++_errorCount;
Logger.Log("No response from the event queue but no reported error either", Helpers.LogLevel.Warning);
}
HandlingDone:
#region Resume the connection
if (_Running)
{
OSDMap osdRequest = new OSDMap();
if (ack != 0)
{
osdRequest["ack"] = OSD.FromInteger(ack);
}
else
{
osdRequest["ack"] = new OSD();
}
osdRequest["done"] = OSD.FromBoolean(_Dead);
byte[] postData = OSDParser.SerializeLLSDXmlBytes(osdRequest);
if (_errorCount > 0) // Exponentially back off, so we don't hammer the CPU
{
Thread.Sleep(_random.Next(500 + (int)Math.Pow(2, _errorCount)));
}
// Resume the connection. The event handler for the connection opening
// just sets class _Request variable to the current HttpWebRequest
CapsBase.UploadDataAsync(_Address, null, "application/xml", postData, REQUEST_TIMEOUT,
delegate(HttpWebRequest newRequest) { _Request = newRequest; }, null, RequestCompletedHandler);
// If the event queue is dead at this point, turn it off since
// that was the last thing we want to do
if (_Dead)
{
_Running = false;
Logger.DebugLog("Sent event queue shutdown message");
}
}
#endregion Resume the connection
#region Handle incoming events
if (OnEvent != null && events != null && events.Count > 0)
{
// Fire callbacks for each event received
foreach (OSDMap evt in events)
{
string msg = evt["message"].AsString();
OSDMap body = (OSDMap)evt["body"];
try { OnEvent(msg, body); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
}
#endregion Handle incoming events
}
void RequestCompletedHandler(HttpWebRequest request, HttpWebResponse response, byte[] responseData, Exception error)
{
// We don't care about this request now that it has completed
_Request = null;
OSDArray events = null;
int ack = 0;
if (responseData != null)
{
_errorCount = 0;
// Got a response
if (OSDParser.DeserializeLLSDXml(responseData) is OSDMap result)
{
events = result["events"] as OSDArray;
ack = result["id"].AsInteger();
}
else
{
Logger.Log("Got an unparseable response from the event queue: \"" +
System.Text.Encoding.UTF8.GetString(responseData) + "\"", Helpers.LogLevel.Warning);
}
}
else if (error != null)
{
#region Error handling
HttpStatusCode code = HttpStatusCode.OK;
if (error is WebException webException)
{
// Filter out some of the status requests to skip handling
switch (webException.Status)
{
case WebExceptionStatus.RequestCanceled:
case WebExceptionStatus.KeepAliveFailure:
goto HandlingDone;
}
if (webException.Response != null)
{
code = ((HttpWebResponse)webException.Response).StatusCode;
}
}
switch (code)
{
case HttpStatusCode.NotFound:
case HttpStatusCode.Gone:
Logger.Log($"Closing event queue at {_Address} due to missing caps URI", Helpers.LogLevel.Info);
_Running = false;
_Dead = true;
break;
case (HttpStatusCode)499: // weird error returned occasionally, ignore for now
case HttpStatusCode.BadGateway:
// This is not good (server) protocol design, but it's normal.
// The EventQueue server is a proxy that connects to a Squid
// cache which will time out periodically. The EventQueue server
// interprets this as a generic error and returns a 502 to us
// that we ignore
break;
default:
++_errorCount;
// Try to log a meaningful error message
if (code != HttpStatusCode.OK)
{
Logger.Log($"Unrecognized caps connection problem from {_Address}: {code}",
Helpers.LogLevel.Warning);
}
else if (error.InnerException != null)
{
Logger.Log(
$"Unrecognized internal caps exception from {_Address}: {error.InnerException.Message}",
Helpers.LogLevel.Warning);
}
else
{
Logger.Log($"Unrecognized caps exception from {_Address}: {error.Message}",
Helpers.LogLevel.Warning);
}
break;
}
#endregion Error handling
}
else
{
++_errorCount;
Logger.Log("No response from the event queue but no reported error either", Helpers.LogLevel.Warning);
}
HandlingDone:
#region Resume the connection
if (_Running)
{
OSDMap osdRequest = new OSDMap();
if (ack != 0)
{
osdRequest["ack"] = OSD.FromInteger(ack);
}
else
{
osdRequest["ack"] = new OSD();
}
osdRequest["done"] = OSD.FromBoolean(_Dead);
byte[] postData = OSDParser.SerializeLLSDXmlBytes(osdRequest);
if (_errorCount > 0) // Exponentially back off, so we don't hammer the CPU
{
Thread.Sleep(Math.Min(REQUEST_BACKOFF_SECONDS + _errorCount * REQUEST_BACKOFF_SECONDS_INC, REQUEST_BACKOFF_SECONDS_MAX));
}
// Resume the connection. The event handler for the connection opening
// just sets class _Request variable to the current HttpWebRequest
CapsBase.UploadDataAsync(_Address, null, REQUEST_CONTENT_TYPE, postData, REQUEST_TIMEOUT,
delegate(HttpWebRequest newRequest) { _Request = newRequest; }, null, RequestCompletedHandler);
// If the event queue is dead at this point, turn it off since
// that was the last thing we want to do
if (_Dead)
{
_Running = false;
Logger.DebugLog("Sent event queue shutdown message");
}
}
#endregion Resume the connection
#region Handle incoming events
if (OnEvent == null || events == null || events.Count <= 0)
{
return;
}
// Fire callbacks for each event received
foreach (var osd in events)
{
var evt = (OSDMap)osd;
string msg = evt["message"].AsString();
OSDMap body = (OSDMap)evt["body"];
try { OnEvent(msg, body); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
#endregion Handle incoming events
}