public CapsClient(Uri capability)
{
_Client = new CapsBase(capability);
_Client.DownloadProgressChanged += new CapsBase.DownloadProgressChangedEventHandler(Client_DownloadProgressChanged);
_Client.UploadProgressChanged += new CapsBase.UploadProgressChangedEventHandler(Client_UploadProgressChanged);
_Client.UploadDataCompleted += new CapsBase.UploadDataCompletedEventHandler(Client_UploadDataCompleted);
_Client.DownloadStringCompleted += new CapsBase.DownloadStringCompletedEventHandler(Client_DownloadStringCompleted);
}
public CapsClient(Uri capability)
{
_Client = new CapsBase(capability);
_Client.DownloadProgressChanged += new DownloadProgressChangedEventHandler(Client_DownloadProgressChanged);
_Client.DownloadDataCompleted += new DownloadDataCompletedEventHandler(Client_DownloadDataCompleted);
_Client.UploadProgressChanged += new UploadProgressChangedEventHandler(Client_UploadProgressChanged);
_Client.UploadDataCompleted += new UploadDataCompletedEventHandler(Client_UploadDataCompleted);
}
public EventQueueClient(Uri eventQueueLocation)
{
_Client = new CapsBase(eventQueueLocation);
_Client.OpenWriteCompleted += new OpenWriteCompletedEventHandler(Client_OpenWriteCompleted);
_Client.UploadDataCompleted += new UploadDataCompletedEventHandler(Client_UploadDataCompleted);
}
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
LLSDMap request = new LLSDMap();
request["ack"] = new LLSD();
request["done"] = LLSD.FromBoolean(false);
byte[] postData = LLSDParser.SerializeXmlBytes(request);
_Client.UploadDataAsync(_Client.Location, postData);
if (raiseEvent)
{
Logger.DebugLog("Capabilities event queue connected");
// The event queue is starting up for the first time
if (OnConnected != null)
{
try { OnConnected(); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
}
}
public EventQueueClient(Uri eventQueueLocation)
{
_Client = new CapsBase(eventQueueLocation);
_Client.OpenWriteCompleted += new CapsBase.OpenWriteCompletedEventHandler(Client_OpenWriteCompleted);
_Client.UploadDataCompleted += new CapsBase.UploadDataCompletedEventHandler(Client_UploadDataCompleted);
}
private void Client_UploadDataCompleted(object sender, CapsBase.UploadDataCompletedEventArgs e)
{
LLSDArray events = null;
int ack = 0;
if (e.Error != null)
{
// Error occurred
string message = e.Error.Message.ToLower();
// Check what kind of exception happened
if (Helpers.StringContains(message, "404") || Helpers.StringContains(message, "410"))
{
Logger.Log("Closing event queue at " + _Client.Location + " due to missing caps URI",
Helpers.LogLevel.Info);
_Running = false;
_Dead = true;
}
else if (!e.Cancelled)
{
HttpWebResponse errResponse = null;
if (e.Error is WebException)
{
WebException err = (WebException)e.Error;
errResponse = (HttpWebResponse)err.Response;
}
// Figure out what type of error was thrown so we can print a meaningful
// error message
if (errResponse != null)
{
switch (errResponse.StatusCode)
{
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:
Logger.Log(String.Format(
"Unrecognized caps connection problem from {0}: {1} (Server returned: {2})",
_Client.Location, errResponse.StatusCode, errResponse.StatusDescription),
Helpers.LogLevel.Warning);
break;
}
}
else if (e.Error.InnerException != null)
{
Logger.Log(String.Format("Unrecognized caps exception from {0}: {1}",
_Client.Location, e.Error.InnerException.Message), Helpers.LogLevel.Warning);
}
else
{
Logger.Log(String.Format("Unrecognized caps exception from {0}: {1}",
_Client.Location, e.Error.Message), Helpers.LogLevel.Warning);
}
}
}
else if (!e.Cancelled && e.Result != null)
{
// Got a response
LLSD result = LLSDParser.DeserializeXml(e.Result);
if (result != null && result.Type == LLSDType.Map)
{
// Parse any events returned by the event queue
LLSDMap map = (LLSDMap)result;
events = (LLSDArray)map["events"];
ack = map["id"].AsInteger();
}
}
else if (e.Cancelled)
{
// Connection was cancelled
Logger.DebugLog("Cancelled connection to event queue at " + _Client.Location);
}
if (_Running)
{
LLSDMap request = new LLSDMap();
if (ack != 0) request["ack"] = LLSD.FromInteger(ack);
else request["ack"] = new LLSD();
request["done"] = LLSD.FromBoolean(_Dead);
byte[] postData = LLSDParser.SerializeXmlBytes(request);
_Client.UploadDataAsync(_Client.Location, postData);
// 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");
}
}
if (OnEvent != null && events != null && events.Count > 0)
{
// Fire callbacks for each event received
foreach (LLSDMap evt in events)
{
string msg = evt["message"].AsString();
LLSDMap body = (LLSDMap)evt["body"];
try { OnEvent(msg, body); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
}
}
private void Client_UploadDataCompleted(object sender, CapsBase.UploadDataCompletedEventArgs e)
{
LLSDArray events = null;
int ack = 0;
if (e.Error != null)
{
// Error occurred
string message = e.Error.Message.ToLower();
// Check what kind of exception happened
if (Helpers.StringContains(message, "404") || Helpers.StringContains(message, "410"))
{
SecondLife.LogStatic("Closing event queue at " + _Client.Location + " due to missing caps URI",
Helpers.LogLevel.Info);
_Running = false;
_Dead = true;
}
else if (!e.Cancelled && !Helpers.StringContains(message, "502"))
{
if (e.Error.InnerException != null)
{
SecondLife.LogStatic("Unrecognized caps exception from " + _Client.Location +
": " + e.Error.InnerException.Message, Helpers.LogLevel.Warning);
}
else
{
SecondLife.LogStatic("Unrecognized caps exception from " + _Client.Location +
": " + e.Error.Message, Helpers.LogLevel.Warning);
}
}
}
else if (!e.Cancelled && e.Result != null)
{
// Got a response
LLSD result = LLSDParser.DeserializeXml(e.Result);
if (result != null && result.Type == LLSDType.Map)
{
// Parse any events returned by the event queue
LLSDMap map = (LLSDMap)result;
events = (LLSDArray)map["events"];
ack = map["id"].AsInteger();
}
}
else if (e.Cancelled)
{
// Connection was cancelled
SecondLife.DebugLogStatic("Cancelled connection to event queue at " + _Client.Location);
}
if (_Running)
{
LLSDMap request = new LLSDMap();
if (ack != 0) request["ack"] = LLSD.FromInteger(ack);
else request["ack"] = new LLSD();
request["done"] = LLSD.FromBoolean(_Dead);
byte[] postData = LLSDParser.SerializeXmlBytes(request);
_Client.UploadDataAsync(_Client.Location, postData);
// 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;
SecondLife.DebugLogStatic("Sent event queue shutdown message");
}
}
if (OnEvent != null && events != null && events.Count > 0)
{
// Fire callbacks for each event received
foreach (LLSDMap evt in events)
{
string msg = evt["message"].AsString();
LLSDMap body = (LLSDMap)evt["body"];
try { OnEvent(msg, body); }
catch (Exception ex) { SecondLife.LogStatic(ex.ToString(), Helpers.LogLevel.Error); }
}
}
}
private void Client_DownloadStringCompleted(object sender, CapsBase.DownloadStringCompletedEventArgs e)
{
if (OnComplete != null && !e.Cancelled)
{
if (e.Error == null)
{
LLSD result = LLSDParser.DeserializeXml(e.Result);
try { OnComplete(this, result, e.Error); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
else
{
if (Helpers.StringContains(e.Error.Message, "502"))
{
// These are normal, retry the request automatically
Logger.DebugLog("502 error from capability " + _Client.Location);
StartRequest(_PostData, _ContentType);
}
else
{
try { OnComplete(this, null, e.Error); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
}
}
else if (e.Cancelled)
{
Logger.DebugLog("Capability action at " + _Client.Location + " cancelled");
}
}
private void Client_UploadProgressChanged(object sender, CapsBase.UploadProgressChangedEventArgs e)
{
if (OnProgress != null)
{
try { OnProgress(this, e.BytesReceived, e.BytesSent, e.TotalBytesToReceive, e.TotalBytesToSend); }
catch (Exception ex) { Logger.Log(ex.Message, Helpers.LogLevel.Error, ex); }
}
}
