public static void Delete(BubbleGroup group) { lock (BubbleGroupDatabase.OperationLock) { var unifiedGroup = @group as UnifiedBubbleGroup; if (unifiedGroup != null) { DeleteUnified(unifiedGroup); return; } var file = BubbleGroupDatabase.GetLocation(@group); if (File.Exists(file)) { File.Delete(file); } BubbleGroupSync.RemoveFromSync(@group); BubbleGroupSync.DeleteBubbleGroupIfHasAgent(@group); BubbleGroupManager.BubbleGroupsRemove(@group); } }
public void InsertByTime(VisualBubble b) { if (Bubbles.Count > BubblesCapSize) { Bubbles.RemoveAt(0); } for (int i = Bubbles.Count - 1; i >= 0; i--) { var nBubble = Bubbles[i]; if (nBubble.Time <= b.Time) { // adding it to the end, we can do a simple contract if (i == Bubbles.Count - 1) { Bubbles.Add(b); if (b.Direction == Bubble.BubbleDirection.Incoming) { BubbleGroupSettingsManager.SetUnread(this, true); } } // inserting, do a full contract else { Bubbles.Insert(i + 1, b); } break; } // could not find a valid place to insert, then skip insertion. if (i == 0) { return; } } if (Unified == null) { _bubblesInsertedCount++; if (_bubblesInsertedCount % 100 == 0) { if (BubbleGroupSync.SupportsSyncAndIsRunning(this)) { Action doSync = async() => { using (Platform.AquireWakeLock("DisaSync")) { await Utils.Delay(1000); await BubbleGroupSync.Sync(this, true); } }; doSync(); } } } RaiseBubbleInserted(b); RaiseUnifiedBubblesUpdatedIfUnified(b); }
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); }); } } })); }
public void InsertByTime(VisualBubble b) { if (Bubbles.Count >= BubblesCapSize) { Bubbles.RemoveAt(0); } if (!(this is ComposeBubbleGroup)) { var unreadIndicatorGuid = BubbleGroupSettingsManager.GetUnreadIndicatorGuid(this); for (int i = Bubbles.Count - 1; i >= 0; i--) { var nBubble = Bubbles[i]; var unreadIndicatorIndex = -1; if (unreadIndicatorGuid != null && unreadIndicatorGuid == nBubble.ID) { unreadIndicatorIndex = i; } // IMPORTANT: Our Time field is specified in seconds, however scenarios are appearing // (e.g., bots) where messages are sent in on the same second but still require // proper ordering. In this case, Services may set a flag specifying a fallback // to the ID assigned by the Service (e.g. Telegram). if ((nBubble.Time == b.Time) && (nBubble.IsServiceIdSequence && b.IsServiceIdSequence)) { if (string.Compare( strA: nBubble.IdService, strB: b.IdService, ignoreCase: false, culture: CultureInfo.InvariantCulture) < 0) { // // Incoming bubble must be placed AFTER current bubble we are evaluating // if (i == Bubbles.Count - 1) { Bubbles.Add(b); if (b.Direction == Bubble.BubbleDirection.Incoming) { BubbleGroupSettingsManager.SetUnread(this, true); } } else { Bubbles.Insert(i + 1, b); if (i >= unreadIndicatorIndex && b.Direction == Bubble.BubbleDirection.Outgoing) { BubbleGroupSettingsManager.SetUnreadIndicatorGuid(this, b.ID, false); } } } else { // // Incoming bubble must be placed BEFORE current bubble we are evaluating // Bubbles.Insert(i, b); if (i >= unreadIndicatorIndex && b.Direction == Bubble.BubbleDirection.Outgoing) { BubbleGroupSettingsManager.SetUnreadIndicatorGuid(this, b.ID, false); } } break; } // OK, simpler scenario, incoming bubble must be placed AFTER current bubble we are evaluating else if (nBubble.Time <= b.Time) { // adding it to the end, we can do a simple contract if (i == Bubbles.Count - 1) { Bubbles.Add(b); if (b.Direction == Bubble.BubbleDirection.Incoming) { BubbleGroupSettingsManager.SetUnread(this, true); } } // inserting, do a full contract else { Bubbles.Insert(i + 1, b); } if (i >= unreadIndicatorIndex && b.Direction == Bubble.BubbleDirection.Outgoing) { BubbleGroupSettingsManager.SetUnreadIndicatorGuid(this, b.ID, false); } break; } // could not find a valid place to insert, then skip insertion. if (i == 0) { return; } } } if (Unified == null) { _bubblesInsertedCount++; if (_bubblesInsertedCount % 100 == 0) { if (BubbleGroupSync.SupportsSyncAndIsRunning(this)) { Action doSync = async() => { using (Platform.AquireWakeLock("DisaSync")) { await Utils.Delay(1000); await BubbleGroupSync.Sync(this, true); } }; doSync(); } } } RaiseBubbleInserted(b); RaiseUnifiedBubblesUpdatedIfUnified(b); }