public static bool LoadFullyIfNeeded(BubbleGroup group, bool sync = false)
{
if (@group == null)
{
return(false);
}
var loadedSomething = false;
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroup = @group as UnifiedBubbleGroup;
var associatedGroups = unifiedGroup != null
? unifiedGroup.Groups.ToList()
: new[] { @group }.ToList();
var associatedPartiallyLoadedGroups = associatedGroups.Where(x => x.PartiallyLoaded).ToList();
foreach (var partiallyLoadedGroup in associatedPartiallyLoadedGroups)
{
loadedSomething = true;
var partiallyLoadedBubblesToRemove = partiallyLoadedGroup.Bubbles.ToList();
foreach (var bubble in BubbleGroupDatabase.FetchBubbles(partiallyLoadedGroup).Reverse())
{
partiallyLoadedGroup.Bubbles.Add(bubble);
}
foreach (var partiallyLoadedBubbleToRemove in partiallyLoadedBubblesToRemove)
{
partiallyLoadedGroup.Bubbles.Remove(partiallyLoadedBubbleToRemove);
}
partiallyLoadedGroup.PartiallyLoaded = false;
}
if (unifiedGroup != null && !unifiedGroup.UnifiedGroupLoaded)
{
Populate(unifiedGroup);
}
}
if (!sync && loadedSomething)
{
Task.Factory.StartNew(() =>
{
var unifiedGroup = @group as UnifiedBubbleGroup;
if (unifiedGroup != null)
{
BubbleQueueManager.Send(unifiedGroup.Groups.Where(x => ServiceManager.IsRunning(x.Service))
.Select(x => x.Service.Information.ServiceName).ToArray());
}
else if (ServiceManager.IsRunning(@group.Service))
{
BubbleQueueManager.Send(new[] { @group.Service.Information.ServiceName });
}
BubbleManager.SetNotQueuedToFailures(@group);
});
}
return(loadedSomething);
}
public static bool LoadFullyIfNeeded(BubbleGroup group, bool sync = false)
{
if (@group == null)
{
return(false);
}
var loadedSomething = false;
lock (BubbleGroupDatabase.OperationLock)
{
var unifiedGroup = @group as UnifiedBubbleGroup;
var adjustUnifiedGroupUnreadIndicatorIfExists = false;
var associatedGroups = unifiedGroup != null
? unifiedGroup.Groups.ToList()
: new[] { @group }.ToList();
var associatedPartiallyLoadedGroups = associatedGroups.Where(x => x.PartiallyLoaded).ToList();
foreach (var partiallyLoadedGroup in associatedPartiallyLoadedGroups)
{
var partiallyLoadedBubblesToRemove = partiallyLoadedGroup.Bubbles.ToList();
var rollingBack = false;
TryAgain:
try
{
loadedSomething = true;
partiallyLoadedGroup.PartiallyLoaded = false;
foreach (var bubble in BubbleGroupDatabase.FetchBubbles(partiallyLoadedGroup).Reverse())
{
partiallyLoadedGroup.Bubbles.Add(bubble);
}
foreach (var partiallyLoadedBubbleToRemove in partiallyLoadedBubblesToRemove)
{
partiallyLoadedGroup.Bubbles.Remove(partiallyLoadedBubbleToRemove);
}
if (partiallyLoadedGroup.Bubbles.Count < 1)
{
foreach (var partiallyLoadedBubbleToRemove in partiallyLoadedBubblesToRemove)
{
partiallyLoadedGroup.Bubbles.Add(partiallyLoadedBubbleToRemove);
}
}
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to fully load partially loaded group " + partiallyLoadedGroup.ID + ": " + ex);
if (!rollingBack)
{
Utils.DebugPrint("Attempting to roll back the last transaction....");
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(partiallyLoadedGroup, null, false);
adjustUnifiedGroupUnreadIndicatorIfExists = true;
rollingBack = true;
var lastModifiedIndex = BubbleGroupIndex.GetLastModifiedIndex(partiallyLoadedGroup.ID);
if (lastModifiedIndex.HasValue)
{
try
{
BubbleGroupDatabase.RollBackTo(partiallyLoadedGroup, lastModifiedIndex.Value);
goto TryAgain;
}
catch (Exception ex2)
{
Utils.DebugPrint("Failed to rollback: " + ex2);
// fall-through. It's unrecoverable!
}
}
else
{
// fall-through. It's unrecoverable!
}
}
Utils.DebugPrint("Partially loaded group is dead. Killing and restarting (lost data occurred).");
BubbleGroupDatabase.Kill(partiallyLoadedGroup);
BubbleGroupSync.RemoveFromSync(partiallyLoadedGroup);
BubbleGroupDatabase.AddBubbles(partiallyLoadedGroup,
partiallyLoadedBubblesToRemove.ToArray());
}
}
if (unifiedGroup != null && !unifiedGroup.UnifiedGroupLoaded)
{
Populate(unifiedGroup);
}
if (unifiedGroup != null && adjustUnifiedGroupUnreadIndicatorIfExists)
{
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(unifiedGroup, null, false);
}
}
if (!sync && loadedSomething)
{
Task.Factory.StartNew(() =>
{
var unifiedGroup = @group as UnifiedBubbleGroup;
if (unifiedGroup != null)
{
BubbleQueueManager.Send(unifiedGroup.Groups.Where(x => ServiceManager.IsRunning(x.Service))
.Select(x => x.Service.Information.ServiceName).ToArray());
}
else if (ServiceManager.IsRunning(@group.Service))
{
BubbleQueueManager.Send(new[] { @group.Service.Information.ServiceName });
}
BubbleQueueManager.SetNotQueuedToFailures(@group);
});
}
return(loadedSomething);
}
public static Task Start(Service service, bool smartStart = false, int smartStartSeconds = 10)
{
return(Task.Factory.StartNew(() =>
{
using (var wakeLock = Platform.AquireWakeLock("DisaStart"))
{
if (IsRunning(service))
{
Utils.DebugPrint(
"The service is already running. Preventing possible deadlock. SmartStart? " +
smartStart);
return;
}
if (IsStarting(service))
{
Utils.DebugPrint(
"The service is being started. Preventing possible deadlock. SmartStart? " +
smartStart);
return;
}
Action epilogue = () => { GetFlags(service).Starting = false; };
lock (service)
{
GetFlags(service).Aborted = false;
GetFlags(service).AbortedSpecial = false;
GetFlags(service).Starting = true;
GetFlags(service).ManualSettingsNeeded = false;
Utils.DebugPrint("Loading settings for service " + service.Information.ServiceName);
try
{
var settings = SettingsManager.Load(service);
if (settings == null)
{
Utils.DebugPrint("Failed to load saved settings for "
+ service.Information.ServiceName +
". Will try to initialize with no settings...");
if (!service.InitializeDefault())
{
Utils.DebugPrint(
"Service doesn't allow initializing without settings. Needs manual input.");
GetFlags(service).ManualSettingsNeeded = true;
ServiceEvents.RaiseServiceManualSettingsNeeded(service);
}
else
{
Utils.DebugPrint("Service initialized under no settings.");
}
}
else
{
Utils.DebugPrint("Loading saved settings! Initializing...");
if (service.Initialize(settings))
{
Utils.DebugPrint("Successfully initialized service!");
}
else
{
Utils.DebugPrint("Failed to initialize service. Needs manual input.");
GetFlags(service).ManualSettingsNeeded = true;
ServiceEvents.RaiseServiceManualSettingsNeeded(service);
}
}
}
catch (Exception ex)
{
Utils.DebugPrint("Failed: " + ex);
epilogue();
return;
}
Utils.DebugPrint("Starting service " + service.Information.ServiceName);
try
{
if (service.Information.UsesInternet &&
!Platform.HasInternetConnection())
{
throw new Exception("No internet connection. Cannot connect service: "
+ service.Information.ServiceName);
}
StartInternal(service, wakeLock);
}
catch (ServiceSchedulerException ex)
{
Utils.DebugPrint("Problem in scheduler: " + ex.Message);
epilogue();
return;
}
catch (ServiceSpecialRestartException)
{
Utils.DebugPrint("Service " + service.Information.ServiceName +
" is asking to be restarted on connect/authenticate. This should be called sparingly, Disa can easily " +
"break under these circumstances. Restarting...");
StopInternal(service);
epilogue();
Start(service, smartStart, smartStartSeconds);
return;
}
catch (ServiceExpiredException)
{
Utils.DebugPrint("The service " + service.Information.ServiceName +
" has expired. :(");
GetFlags(service).Aborted = true;
GetFlags(service).Expired = true;
ServiceEvents.RaiseServiceExpired(service);
StopInternal(service);
epilogue();
return;
}
catch (Exception ex)
{
if (smartStart)
{
StopInternal(service, false);
if (smartStartSeconds > 600)
{
Utils.DebugPrint("Service " + service.Information.ServiceName +
" needs to wait over 10minutes to be restarted." +
" Killing SmartStart. The service will not be restarted. Reason: " + ex);
epilogue();
return;
}
Utils.DebugPrint("Service " + service.Information.ServiceName +
" failed to be started. SmartStart enabled. "
+ "Service being scheduled to be re-started in T-" +
smartStartSeconds + " seconds! Reason: " + ex);
var hasSmartStart = new object();
service.HasSmartStart = hasSmartStart;
Platform.ScheduleAction(smartStartSeconds,
new WakeLockBalancer.ActionObject(() =>
{
if (IsAborted(service))
{
Utils.DebugPrint(
"Service " +
service.Information
.ServiceName +
" tried to be started, but it deemed killed.");
return;
}
if (service.HasSmartStart !=
hasSmartStart)
{
Utils.DebugPrint(
"This smart start has been invalidated. There " +
"seems to be another one on the block.");
return;
}
Utils.DebugPrint(
"Smart start is firing the service " +
service.Information
.ServiceName +
" up again!");
StopInternal(service);
Start(service, true, smartStartSeconds * 2);
}, WakeLockBalancer.ActionObject.ExecuteType.TaskWithWakeLock));
epilogue();
return;
}
Utils.DebugPrint("Failed to start service " + service.Information.ServiceName +
" (No SmartStart) : " + ex);
StopInternal(service, false);
epilogue();
return;
}
BubbleManager.SendSubscribe(service, true);
BubbleManager.SendLastPresence(service);
service.ReceivingBubblesThread = new Thread(() =>
{
try
{
StartReceiveBubbles(service);
}
catch (ThreadAbortException)
{
Utils.DebugPrint(
"Abort thread excepton in receiving bubbles on service (outer thread) " +
service.Information.ServiceName);
}
catch (Exception ex)
{
Utils.DebugPrint(">>>>>>>>> " + ex.Message + " " + ex.StackTrace);
}
Utils.DebugPrint("Receiving bubbles for service " +
service.Information.ServiceName + " has come to an end.");
});
service.ReceivingBubblesThread.Start();
GetFlags(service).Starting = false;
BubbleManager.SetNotQueuedToFailures(service);
Utils.Delay(1000).ContinueWith(x =>
{
BubbleGroupSync.ResetSyncsIfHasAgent(service);
BubbleGroupUpdater.Update(service);
BubbleQueueManager.Send(new[] { service.Information.ServiceName });
BubbleGroupManager.ProcessUpdateLastOnlineQueue(service);
});
}
}
}));
}
internal static void OnBubbleReceived(Bubble b)
{
var visualBubble = b as VisualBubble;
if (visualBubble != null)
{
try
{
BubbleManager.Group(visualBubble);
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in OnBubbleReceived (VisualBubble) from service " +
visualBubble.Service.Information.ServiceName + ": " + ex.Message);
}
if (visualBubble.Direction == Bubble.BubbleDirection.Incoming &&
IsRunning(visualBubble.Service) &&
BubbleQueueManager.HasQueuedBubbles(b.Service.Information.ServiceName, true, true))
{
Utils.DebugPrint("Sending queued bubbles as we're getting some received.");
BubbleQueueManager.Send(new [] { b.Service.Information.ServiceName });
}
}
else if (b is AbstractBubble)
{
Utils.DebugPrint("We got an abstract bubble: " + b.GetType().Name + " Address: " + b.Address);
BubbleGroup group = null;
var deliveredBubble = b as DeliveredBubble;
if (deliveredBubble != null)
{
@group = BubbleGroupManager.FindWithAddress(deliveredBubble.Service, deliveredBubble.Address);
if (@group != null)
{
BubbleGroupFactory.LoadFullyIfNeeded(@group);
var bubbles = @group.Bubbles;
for (var i = bubbles.Count - 1; i >= 0; i--)
{
var bubble = bubbles[i];
if (bubble.ID != deliveredBubble.VisualBubbleID)
{
continue;
}
BubbleManager.UpdateStatus(bubble, Bubble.BubbleStatus.Delivered, @group);
if (@group.Service.Information.DoesSupport(typeof(DeliveredBubbleReceipt)))
{
BubbleManager.Send(new DeliveredBubbleReceipt(Time.GetNowUnixTimestamp(), Bubble.BubbleDirection.Outgoing,
@group.Service, bubble));
}
break;
}
}
}
var readBubble = b as ReadBubble;
if (readBubble != null)
{
@group = BubbleGroupManager.FindWithAddress(readBubble.Service, readBubble.Address);
if (@group != null)
{
BubbleGroupFactory.LoadFullyIfNeeded(@group);
if (@group.ReadTimes == null || [email protected])
{
@group.ReadTimes = new []
{
new DisaReadTime
{
ParticipantAddress = readBubble.ParticipantAddress,
Time = readBubble.ReadTime
}
};
}
else
{
var readTimes = @group.ReadTimes.ToList();
var duplicateReadTime = readTimes.FirstOrDefault(x =>
@group.Service.BubbleGroupComparer(x.ParticipantAddress, readBubble.ParticipantAddress));
if (duplicateReadTime != null)
{
readTimes.Remove(duplicateReadTime);
}
readTimes.Add(new DisaReadTime
{
ParticipantAddress = readBubble.ParticipantAddress,
Time = readBubble.ReadTime
});
@group.ReadTimes = readTimes.ToArray();
}
}
}
var prescenceBubble = b as PresenceBubble;
if (prescenceBubble != null)
{
@group = BubbleGroupManager.Find(bubbleGroup =>
!bubbleGroup.IsParty &&
bubbleGroup.Service ==
prescenceBubble.Service &&
prescenceBubble.Service.BubbleGroupComparer(
bubbleGroup.Address,
prescenceBubble.Address));
if (@group != null)
{
if ([email protected] && !prescenceBubble.Available)
{
var oldPresence = @group.PresenceType;
@group.PresenceType = PresenceBubble.PresenceType.Unavailable;
if (oldPresence != prescenceBubble.Presence)
{
BubbleGroupManager.UpdateLastOnline(@group);
}
}
else
{
@group.PresenceType = prescenceBubble.Presence;
@group.PresencePlatformType = prescenceBubble.Platform;
}
if (!prescenceBubble.Available)
{
@group.Typing = false;
}
}
}
var typingBubble = b as TypingBubble;
if (typingBubble != null)
{
@group = BubbleGroupManager.Find(bubbleGroup =>
!bubbleGroup.IsParty &&
bubbleGroup.Service ==
typingBubble.Service &&
typingBubble.Service.BubbleGroupComparer(
bubbleGroup.Address,
typingBubble.Address));
if (@group != null)
{
if (@group.Presence)
{
@group.Typing = typingBubble.Typing;
@group.TypingIsAudio = typingBubble.IsAudio;
}
else
{
@group.Typing = false;
}
}
}
try
{
if (@group != null)
{
BubbleGroupEvents.RaiseNewAbstractBubble(b as AbstractBubble, @group);
}
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in OnBubbleReceived (AbstractBubble) from service " +
b.Service.Information.ServiceName + ": " + ex.Message);
}
}
}
public static Task <List <Receipt> > Send(string[] serviceNames, bool scheduled = false)
{
return(Task <List <Receipt> > .Factory.StartNew(() =>
{
//PROCESS: 1) find all bubbles under serviceNames in db
// 2) relate db entries to bubbles loaded into memory by Disa
// 3) parallel send bubbles based respective to service
// 4) delete all successful bubbles out of db
lock (_sendLock)
{
var possibleBubblesFromDatabase = new List <Entry>();
lock (_dbLock)
{
using (var db = new SqlDatabase <Entry>(Location))
{
foreach (var possibleBubble in db.Store.Where(x => serviceNames.Contains(x.ServiceName)).Reverse())
{
if (!InsertBubble.IsSending(possibleBubble.Guid))
{
possibleBubblesFromDatabase.Add(possibleBubble);
}
}
}
}
var possibleBubblesInDisa = new List <Tuple <Entry, VisualBubble> >();
foreach (var bubbleGroup in BubbleGroupManager.BubbleGroupsNonUnified)
{
if (bubbleGroup.PartiallyLoaded)
{
continue;
}
foreach (var bubble in bubbleGroup)
{
if (bubble.Status != Bubble.BubbleStatus.Waiting)
{
continue;
}
var possibleBubbleFromDatabase = possibleBubblesFromDatabase.FirstOrDefault(x => x.Guid == bubble.ID);
if (possibleBubbleFromDatabase != null)
{
possibleBubblesInDisa.Add(new Tuple <Entry, VisualBubble>(possibleBubbleFromDatabase, bubble));
}
}
}
var sent = new List <Tuple <Entry, bool> >();
var possibleBubblesInDisaByService = possibleBubblesInDisa.GroupBy(x => x.Item1.ServiceName);
Parallel.ForEach(possibleBubblesInDisaByService, possibleBubblesInService =>
{
var failed = false;
foreach (var possibleBubble in possibleBubblesInService)
{
if (failed)
{
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, false));
continue;
}
Utils.DebugPrint(">>>>>>>>>>> Sending queued bubble on "
+ possibleBubble.Item2.Service.Information.ServiceName + "!");
var sendBubbleTask = BubbleManager.Send(possibleBubble.Item2, true);
sendBubbleTask.Wait();
if (sendBubbleTask.Result)
{
Utils.DebugPrint(">>>>>>>>> Successfully sent queued bubble on " +
possibleBubble.Item2.Service.Information.ServiceName + "!");
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, true));
lock (_dbLock)
{
using (var db = new SqlDatabase <Entry>(Location))
{
db.Remove(possibleBubble.Item1);
}
}
Utils.Delay(100).Wait();
}
else
{
Utils.DebugPrint(">>>>>>>>> Failed to send queued bubble on " +
possibleBubble.Item2.Service.Information.ServiceName + "!");
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, false));
failed = true; // fail the entire chain for this service from here on out so messages aren't sent out of order
}
}
});
SanityCheckup();
var receipts = sent.Select(x => new Receipt(x.Item1.Guid, x.Item2)).ToList();
if (!scheduled)
{
if (receipts.FirstOrDefault(x => !x.Success) != null)
{
ScheduleReSend(serviceNames);
}
else
{
var needToSendAgain = serviceNames.Where(x => BubbleQueueManager.HasQueuedBubbles(x, true, true)).ToArray();
if (needToSendAgain.Any())
{
Send(needToSendAgain);
}
}
}
return receipts;
}
}));
}
private static Task <bool> Send(Bubble b, BubbleGroup group, bool resend)
{
return(Task <bool> .Factory.StartNew(() =>
{
var vb = b as VisualBubble;
if (vb != null)
{
if (vb.Status == Bubble.BubbleStatus.Sent)
{
Utils.DebugPrint("Trying to send a bubble that is already sent! On " + vb.Service.Information.ServiceName);
return true;
}
Func <bool> restartServiceIfNeeded = () =>
{
if (!ServiceManager.IsRegistered(b.Service) ||
ServiceManager.IsRunning(b.Service) ||
ServiceManager.IsAborted(b.Service))
{
return false;
}
Utils.DebugPrint(
"For f***s sakes. The scheduler isn't doing it's job properly, or " +
"you're sending a message to it at a weird time. Starting it up bra (" +
b.Service.Information.ServiceName + ").");
ServiceManager.AbortAndRestart(b.Service);
return true;
};
var visualBubbleServiceId = vb.Service as IVisualBubbleServiceId;
if (vb.IdService == null && vb.IdService2 == null && visualBubbleServiceId != null)
{
visualBubbleServiceId.AddVisualBubbleIdServices(vb);
}
try
{
@group = Group(vb, resend, true);
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in Send:GroupBubble from service " +
vb.Service.Information.ServiceName + ": " + ex.Message);
return false;
}
if (@group == null)
{
Utils.DebugPrint("Could not find a suitable group for bubble " + vb.ID
+ " on " + vb.Service.Information.ServiceName);
return false;
}
var shouldQueue = vb.Service.QueuedBubblesParameters == null ||
!vb.Service.QueuedBubblesParameters.BubblesNotToQueue.Contains(vb.GetType());
try
{
if (shouldQueue && !resend &&
BubbleQueueManager.HasQueuedBubbles(vb.Service.Information.ServiceName,
true, false))
{
BubbleQueueManager.JustQueue(group, vb);
restartServiceIfNeeded();
return false;
}
if (shouldQueue)
{
Monitor.Enter(vb.Service.SendBubbleLock);
}
using (var queued = new BubbleQueueManager.InsertBubble(group, vb, shouldQueue))
{
Action checkForQueued = () =>
{
if (!resend &&
BubbleQueueManager.HasQueuedBubbles(vb.Service.Information.ServiceName, true, true))
{
BubbleQueueManager.Send(new [] { vb.Service.Information.ServiceName });
}
};
try
{
FailBubbleIfPathDoesntExist(vb);
SendBubbleInternal(b);
}
catch (ServiceQueueBubbleException ex)
{
Utils.DebugPrint("Queuing visual bubble on service " +
vb.Service.Information.ServiceName + ": " + ex.Message);
UpdateStatus(vb, Bubble.BubbleStatus.Waiting, @group);
if (!restartServiceIfNeeded())
{
checkForQueued();
}
return false;
}
catch (Exception ex)
{
queued.CancelQueue();
Utils.DebugPrint("Visual bubble on " +
vb.Service.Information.ServiceName + " failed to be sent: " +
ex);
UpdateStatus(vb, Bubble.BubbleStatus.Failed, @group);
BubbleGroupEvents.RaiseBubbleFailed(vb, @group);
if (!restartServiceIfNeeded())
{
checkForQueued();
}
//FIXME: if the bubble fails to send, allow the queue manager to continue.
if (resend)
{
return true;
}
return false;
}
queued.CancelQueue();
lock (BubbleGroupManager.LastBubbleSentTimestamps)
{
BubbleGroupManager.LastBubbleSentTimestamps[group.ID] = Time.GetNowUnixTimestamp();
}
if (vb.Status == Bubble.BubbleStatus.Delivered)
{
Utils.DebugPrint(
"************ Race condition. The server set the status to delivered/read before we could send it to sent. :')");
checkForQueued();
return true;
}
UpdateStatus(vb, Bubble.BubbleStatus.Sent, @group);
checkForQueued();
return true;
}
}
finally
{
if (shouldQueue)
{
Monitor.Exit(vb.Service.SendBubbleLock);
}
}
}
else
{
var composeBubble = b as ComposeBubble;
if (composeBubble != null)
{
var bubbleToSend = composeBubble.BubbleToSend;
var visualBubbleServiceId = bubbleToSend.Service as IVisualBubbleServiceId;
if (bubbleToSend.IdService == null && bubbleToSend.IdService2 == null &&
visualBubbleServiceId != null)
{
visualBubbleServiceId.AddVisualBubbleIdServices(bubbleToSend);
}
@group.InsertByTime(bubbleToSend);
try
{
BubbleGroupEvents.RaiseBubbleInserted(bubbleToSend, @group);
}
catch
{
// do nothing
}
}
try
{
SendBubbleInternal(b);
}
catch (ServiceBubbleGroupAddressException ex)
{
if (!String.IsNullOrWhiteSpace(ex.Address))
{
if (composeBubble != null)
{
composeBubble.BubbleToSend.Address = ex.Address;
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Sent;
var actualGroup = Group(composeBubble.BubbleToSend, resend, true);
ServiceEvents.RaiseComposeFinished(
@group as ComposeBubbleGroup, actualGroup);
return true;
}
}
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
return false;
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to send bubble on service " + b.Service.Information.ServiceName);
if (composeBubble != null)
{
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
}
return false;
}
if (composeBubble != null)
{
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
return false;
}
return true;
}
}));
}
