コード例 #1
0
ファイル: WorkEvents.cs プロジェクト: zacker150/Ao3-Tracker
        public static WorkEvents GetEvent(long workid)
        {
            WorkEvents e;

            if (events.TryGetValue(workid, out e))
            {
                return(e);
            }
            return(events[workid] = new WorkEvents());
        }
コード例 #2
0
        public Task SetWorkChaptersAsync(IDictionary <long, WorkChapter> works)
        {
            return(Task.Run(() =>
            {
                using (ReadWriteLock.WriteLock())
                {
                    long time = DateTime.UtcNow.ToUnixTime();
                    Dictionary <long, Work> newitems = new Dictionary <long, Work>();
                    bool do_delayed = false;

                    foreach (var work in works)
                    {
                        if (work.Value.workid == 0)
                        {
                            work.Value.workid = work.Key;
                        }
                        else if (work.Value.workid != work.Key)
                        {
                            throw new ArgumentException("Value.workid != Key", nameof(works));
                        }

                        if (!storage.TryGetValue(work.Key, out var old) || old.LessThan(work.Value))
                        {
                            var seq = work.Value.seq;
                            if (seq == null && old != null)
                            {
                                seq = old.Seq;
                            }

                            var w = new Work
                            {
                                workid = work.Key,
                                number = work.Value.number,
                                chapterid = work.Value.chapterid,
                                location = work.Value.location,
                                Timestamp = time,
                                Seq = seq ?? 0,
                            };

                            unsynced[work.Key] = newitems[work.Key] = storage[work.Key] = w;

                            // Do a delayed since if we finished a chapter, or started a new one
                            if (old == null || work.Value.location == null || work.Value.location == 0 || work.Value.number > old.number || work.Value.seq > old.Seq)
                            {
                                do_delayed = true;
                                WorkEvents.TryGetEvent(work.Key)?.OnChapterNumChanged(this, w);
                            }
                            else
                            {
                                WorkEvents.TryGetEvent(work.Key)?.OnLocationChanged(this, w);
                            }
                        }
                    }

                    if (newitems.Count > 0)
                    {
                        App.Database.SaveItems(newitems.Values.ToReadOnly());

                        if (serversync == SyncState.Ready || serversync == SyncState.Delayed)
                        {
                            if (do_delayed)
                            {
                                DelayedSyncAsync(10 * 1000);
                            }
                            else
                            {
                                DoSyncAsync();
                            }
                        }
                    }
                }
            }));
        }
コード例 #3
0
        public void DoSyncAsync(bool force = false)
        {
            Task.Factory.StartNew(() =>
            {
                using (ReadWriteLock.UpgradeableReadLock())
                {
                    var settings = new JsonSerializerSettings()
                    {
                        MissingMemberHandling = MissingMemberHandling.Ignore
                    };

                    Dictionary <long, Work> items;
                    Dictionary <long, Work> current;
                    long time;
                    long old_sync;

                    Task <HttpResponseMessage> responseTask;
                    HttpResponseMessage response;
                    Task <string> contentTask;
                    string content;

                    using (ReadWriteLock.WriteLock())
                    {
                        if (serversync == SyncState.Disabled)
                        {
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(false));
                            //console.warn("dosync: FAILED. No credentials");
                            return;
                        }

                        // if we have waiting readers do it now
                        if (ReadWriteLock.WaitingReadCount > 0)
                        {
                            force = true;
                        }

                        // Enforce 5 minutes gap between server sync. Don't want to hammer the server while scrolling through a fic
                        var now = DateTime.UtcNow.Ticks / 10000;
                        if (!force && now < no_sync_until)
                        {
                            //console.log("dosync: have to wait %i for timeout", no_sync_until - now);
                            DelayedSyncAsync((int)(no_sync_until - now));
                            return;
                        }

                        serversync = SyncState.Syncing; // set to syncing!

                        if (DelayedSyncCTS != null)
                        {
                            DelayedSyncCTS.Cancel();
                            DelayedSyncCTS = null;
                        }
                        no_sync_until = now + 5 * 60 * 1000;

                        BeginSyncEvent?.Invoke(this, EventArgs.Empty);

                        //console.log("dosync: sending GET request");

                        responseTask = HttpClient.GetAsync(new Uri(url_base, "Values?after=" + last_sync));
                        responseTask.TryWait();
                        response = responseTask.IsFaulted ? null : responseTask.Result;

                        if (response == null || !response.IsSuccessStatusCode)
                        {
                            using (ReadWriteLock.WriteLock())
                            {
                                //console.error("dosync: FAILED %s", response.ReasonPhrase);
                                if (response != null && response.StatusCode == HttpStatusCode.Forbidden)
                                {
                                    serversync = SyncState.Disabled;
                                }
                                else
                                {
                                    serversync = SyncState.Ready;
                                }
                                EndSyncEvent?.Invoke(this, new EventArgs <bool>(false));
                                return;
                            }
                        }

                        contentTask = response.Content.ReadAsStringAsync();
                        contentTask.Wait();
                        content = contentTask.Result;

                        old_sync = last_sync;

                        try
                        {
                            items = JsonConvert.DeserializeObject <Dictionary <long, Work> >(content, settings);
                        }
                        catch (Exception e)
                        {
                            App.Log(e);
                            serversync = SyncState.Disabled;
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(false));
                            return;
                        }

                        Dictionary <long, Work> newitems = new Dictionary <long, Work>();
                        foreach (var item in items)
                        {
                            item.Value.workid = item.Key;
                            // Highest time value of incoming item is our new sync time
                            if (item.Value.Timestamp > last_sync)
                            {
                                last_sync = item.Value.Timestamp;
                            }

                            Work old = null;
                            if (!storage.ContainsKey(item.Key) || (old = storage[item.Key]).LessThanOrEqual(item.Value))
                            {
                                // Remove from unsynced list (if it exists)
                                if (unsynced.ContainsKey(item.Key))
                                {
                                    unsynced.Remove(item.Key);
                                }
                                // Grab the new details
                                newitems[item.Key] = storage[item.Key] = item.Value;

                                if (old == null || item.Value.location == null || item.Value.location == 0 || (old != null && item.Value.number > old.number))
                                {
                                    WorkEvents.TryGetEvent(item.Key)?.OnChapterNumChanged(this, item.Value);
                                }
                                else
                                {
                                    WorkEvents.TryGetEvent(item.Key)?.OnLocationChanged(this, item.Value);
                                }
                            }
                            // This kinda shouldn't happen, but apparently it did... we can deal with it though
                            else
                            {
                                // Update the timestamp to newer than newest
                                if (storage[item.Key].Timestamp <= item.Value.Timestamp)
                                {
                                    storage[item.Key].Timestamp = item.Value.Timestamp + 1;
                                }
                                else
                                {
                                    item.Value.Timestamp += 1;
                                }
                                // set as unsynced
                                unsynced[item.Key] = storage[item.Key];
                            }
                        }
                        App.Database.SaveItems(newitems.Values.ToReadOnly());

                        current  = unsynced;
                        unsynced = new Dictionary <long, Work>();
                        time     = last_sync;

                        if (current.Count == 0)
                        {
                            App.Database.SaveVariable("last_sync", last_sync);
                            serversync = SyncState.Ready;
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(true));
                            return;
                        }
                    }

                    foreach (var item in current.Values)
                    {
                        if (item.Timestamp > time)
                        {
                            time = item.Timestamp;
                        }
                    }

                    var json     = JsonConvert.SerializeObject(current);
                    var postBody = new StringContent(json, System.Text.Encoding.UTF8, "application/json");
                    responseTask = HttpClient.PostAsync(new Uri(url_base, "Values"), postBody);
                    responseTask.TryWait();
                    response = responseTask.IsFaulted ? null : responseTask.Result;

                    if (response == null || !response.IsSuccessStatusCode)
                    {
                        using (ReadWriteLock.WriteLock())
                        {
                            //console.error("dosync: FAILED %s", response.ReasonPhrase);
                            if (response != null && response.StatusCode == HttpStatusCode.Forbidden)
                            {
                                last_sync  = 0;
                                serversync = SyncState.Disabled;
                            }
                            else
                            {
                                last_sync  = old_sync;
                                serversync = SyncState.Ready;
                                unsynced   = current;
                            }
                            App.Database.SaveVariable("last_sync", last_sync);
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(false));
                            return;
                        }
                    }

                    contentTask = response.Content.ReadAsStringAsync();
                    contentTask.Wait();
                    content = contentTask.Result;

                    try
                    {
                        items = JsonConvert.DeserializeObject <Dictionary <long, Work> >(content, settings);
                    }
                    catch (Exception e)
                    {
                        App.Log(e);
                        using (ReadWriteLock.WriteLock())
                        {
                            serversync = SyncState.Disabled;
                            App.Database.SaveVariable("last_sync", 0L);
                            last_sync = 0;
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(false));
                            return;
                        }
                    }

                    //console.log("dosync: SUCCESS. %i conflicted items", Object.keys(items).length);
                    using (ReadWriteLock.WriteLock())
                    {
                        if (items.Count > 0)
                        {
                            App.Database.SaveVariable("last_sync", 0L);
                            last_sync = 0;
                            DoSyncAsync(true);
                            return;
                        }
                        if (time > last_sync)
                        {
                            last_sync = time;
                            App.Database.SaveVariable("last_sync", time);
                        }

                        if (unsynced.Count > 0)
                        {
                            DoSyncAsync(true);
                        }
                        else
                        {
                            serversync = SyncState.Ready;
                            EndSyncEvent?.Invoke(this, new EventArgs <bool>(true));
                        }
                    }
                }
            }, TaskCreationOptions.PreferFairness | TaskCreationOptions.LongRunning);
        }