void HandleSessionStarted(ActionRequest Req)
{
Session Data = new Session(Req);
lock (ActiveSessions)
{
ActiveSessions[Data.Requester.GetBareJID() + Data.ID] = Data;
if (Data.SessionEndsAtUTC < NextSweepNeeded)
{
NextSweepNeeded = Data.SessionEndsAtUTC;
}
}
if (SessionStarted != null)
{
SessionStarted.Invoke(Data);
}
ActionResponse Resp = new ActionResponse();
Resp.ID = Req.ID;
Resp.Successful = true;
StanzaMessage RespMessage = new StanzaMessage();
RespMessage.To = Orchestrator;
RespMessage.Payload.Add(Resp.GetXML("genericresponse", Req.Name));
RespMessage.MessageType = StanzaMessage.StanzaMessageType.Normal;
Uplink.SendStanza(RespMessage);
}
void Uplink_OnStanzaMessage(StanzaMessage Data)
{
if (Data.From.GetBareJID() != DataSourceAddress.GetBareJID())
{
return;
}
Console.WriteLine("Controller received message stanza");
XElement LWTSDElement = Data.Payload.Elements().First();
if (LWTSDElement.Name.Namespace != LWTSD.Namespace)
{
return;
}
switch (LWTSDElement.Name.LocalName)
{
case "subscription-cancelled":
HandleSubscriptionCancelled(LWTSDElement);
break;
case "subscription-triggered":
HandleSubscriptionTriggered(LWTSDElement);
break;
}
}
void Uplink_OnStanzaMessage(StanzaMessage Data)
{
try
{
if (Data.From.GetBareJID() != Orchestrator.GetBareJID())
{
return;
}
XElement ActEl = Data.Payload.Element(CDO.Namespace + "actionrequest");
if (ActEl == null)
{
return;
}
ActionRequest Req = new ActionRequest(ActEl);
switch (Req.Name)
{
case "sessionstarted":
HandleSessionStarted(Req);
break;
case "sessionterminated":
HandleSessionTerminated(Req);
break;
}
}
catch (System.Exception ex)
{
Console.WriteLine("Uncatched exception in on stanzamessage: " + ex.ToString());
}
}
public async Task <ActionResponse> Request(string Name, XElement Payload, int TimeoutSeconds = 60)
{
if (LastSynchronizedTime < DateTime.UtcNow.AddMinutes(-60))
{
await SynchTime();
}
ActionRequest Request = new ActionRequest()
{
TimesOut = DateTime.UtcNow.AddSeconds(TimeoutSeconds + TimeDifferenceSeconds),
AckTimesOut = DateTime.UtcNow.AddSeconds(5 + TimeDifferenceSeconds),
Name = Name,
Payload = Payload
};
TaskCompletionSource <ActionResponse> Signal = new TaskCompletionSource <ActionResponse>();
ActionResponses[Request.ID] = Signal;
StanzaMessage Message = new StanzaMessage();
Message.MessageType = StanzaMessage.StanzaMessageType.Normal;
Message.To = Orchestrator;
Message.Payload.Add(Request.GetXML());
Uplink.SendStanza(Message);
if (Signal.Task != await Task.WhenAny(Signal.Task, Task.Delay(TimeoutSeconds * 1000)))
{
ActionResponses.TryRemove(Request.ID, out Signal);
return(new ActionResponse()
{
ID = Request.ID,
Successful = false,
TimedOut = true
});
}
if (Signal.Task.Result == null)
{
throw new Exception("Failed to make request");
}
return(Signal.Task.Result);
}
public void CancelSubscription(string SubscriptionID)
{
Subscription Sub;
if (!Subscriptions.ContainsKey(SubscriptionID))
{
return;
}
Subscriptions.TryRemove(SubscriptionID, out Sub);
StanzaMessage Request = new StanzaMessage();
Request.To = DataSourceAddress;
XElement Payload = new XElement(LWTSD.Namespace + "cancel-subscription");
Payload.SetAttributeValue("subscriptionid", Sub.ID);
Request.Payload.Add(Payload);
Uplink.SendStanza(Request);
}
void Uplink_OnStanzaMessage(StanzaMessage Data)
{
if (!Data.Payload.HasElements)
{
return;
}
XElement LWTSDElement = Data.Payload.Elements().First();
if (LWTSDElement.Name.Namespace != LWTSD.Namespace)
{
return;
}
switch (LWTSDElement.Name.LocalName)
{
case "subscription-cancelled":
HandleSubscriptionCancelled(Data);
break;
}
}
void HandleSubscriptionCancelled(StanzaMessage Request)
{
XElement SubscribeElement = Request.Payload.Elements().First();
try
{
string localsid = SubscribeElement.Attribute("subscriptionid").Value;
string sid = GetSafeSubscriptionID(Request.From, localsid);
if (!Subscribers.ContainsKey(sid))
{
return;
}
Subscriber Temp;
Subscribers.TryRemove(sid, out Temp);
}
catch
{
// No
}
}
void Uplink_OnStanzaMessage(StanzaMessage Data)
{
//Console.WriteLine(Data.ToString());
XElement RespEl = Data.Payload.Element(CDO.Namespace + "actionresponse");
if (RespEl == null)
{
return;
}
ActionResponse Response = new ActionResponse(RespEl);
TaskCompletionSource <ActionResponse> Signal;
if (!ActionResponses.TryRemove(Response.ID, out Signal))
{
return;
}
Signal.SetResult(Response);
}
public void InvalidateData(JID ExcludeJID)
{
List <string> SubscriptionsToRemove = new List <string>();
foreach (string key in Subscribers.Keys)
{
Subscriber s = Subscribers[key];
try
{
if (ExcludeJID != null)
{
if (s.SubscriberAddress == ExcludeJID)
{
continue;
}
}
if (s.LastInvalidated > s.LastResubscribed)
{
continue;
}
List <ResourceAccess> LimitedAccess = GetAccessRights(s.SubscriberAddress, s.AccessToken);
bool Invalidate = false;
foreach (ResourceSubscription trigger in s.Triggers)
{
if (!ResourceAccess.AllowsRead(LimitedAccess, trigger.Path))
{
throw new AccessViolation();
}
Resource res = Resources[trigger.Path];
if (res.ModifiedAt > s.LastInvalidated)
{
Invalidate = true;
break;
}
}
if (!Invalidate)
{
continue;
}
// Invalidate
StanzaMessage InvalidateMessage = new StanzaMessage();
InvalidateMessage.MessageType = StanzaMessage.StanzaMessageType.Normal;
InvalidateMessage.To = s.SubscriberAddress;
s.LastInvalidated = DateTime.UtcNow;
XElement SubscriptionTriggeredElement = new XElement(LWTSD.Namespace + "subscription-triggered");
SubscriptionTriggeredElement.SetAttributeValue("subscriptionid", s.SubscriptionID);
InvalidateMessage.Payload.Add(SubscriptionTriggeredElement);
Uplink.SendStanza(InvalidateMessage);
}
catch (AccessViolation Violation)
{
SubscriptionsToRemove.Add(key);
}
}
foreach (string ToRemove in SubscriptionsToRemove)
{
Subscriber Temp;
Subscribers.TryRemove(ToRemove, out Temp);
}
}
