Esempio n. 1
0
        private async Task LaborCheck(CancellationToken token)
        {
            List <Labordaten> alte = null;

            while (!TryGetNewestLabors(out alte))
            {
                await Task.Delay(1000, token);
            }
            while (true)
            {
                if (ConfigHelper.GetBoolean("LaborCheckEnabled", true))
                {
                    List <Labordaten> neue = null;
                    while (!TryGetNewestLabors(out neue))
                    {
                        await Task.Delay(1000, token);
                    }
                    List <Labordaten> unEquals = GetDifferentLabors(alte, neue);
                    if (unEquals.Count > 0)
                    {
                        string labors = "Neue Labor Versionen gesichtet! - " + unEquals.Select(x => $"{x.Typ} ({x.Version})").Join(", ") + " - Zum Labor: " + Toolbox.ShortUrl("http://www.avm.de/de/Service/Service-Portale/Labor/index.php");
                        ServerManager.AnnounceGlobal(labors);
                        NotifySubscribers(labors);
                        alte = neue;
                    }
                    await Task.Delay(ConfigHelper.GetInt("LaborCheckIntervall", 300000), token);
                }
                else
                {
                    await Task.Delay(30000, token);
                }
            }
        }
Esempio n. 2
0
        private async Task NewsThread(CancellationToken token)
        {
            const string newsUrl = "http://avm.de/service/downloads/update-news/";

            List <NewsEntry> news = await GetNews(newsUrl, token);

            while (true)
            {
                await Task.Delay(ConfigHelper.GetInt("NewsCheckIntervall", 300) * 1000, token);

                List <NewsEntry> updatedNews = await GetNews(newsUrl, token);

                if (updatedNews.Count == 0)
                {
                    Log.Warning("Keine News gefunden");
                    continue;
                }

                if (news.Count == 0)
                {
                    Log.Warning("Es waren keine referenz News vorhanden, verwende News aus diesem Poll als Referenz für den nächsten Poll");
                    news = updatedNews;
                    continue;
                }

                var maxOld = DateTime.Today.AddDays(-1);
                List <NewsEntry> newNews = updatedNews.Where(x => x.Datum > maxOld).Except(news.Where(x => x.Datum > maxOld)).ToList();
                if (newNews.Count > 0)
                {
                    if (newNews.Count == news.Count)
                    {
                        Log.Warning("Anzahl neuer News entspricht anzahl News insgesamt. Überspringe Meldung auf verdacht");
                        news = updatedNews;
                        continue;
                    }

                    string output = $"Neue News: {newNews.Select(x => $"{x.Titel} ({x.Version})").Distinct().Join(", ")} Auf zu den News: {newsUrl}";
                    ServerManager.AnnounceGlobal(output);
                    NotifySubscribers(output);
                }
                news = updatedNews;
            }
        }
Esempio n. 3
0
        public async Task WorkerThread(CancellationToken token)
        {
            // https://osp.avm.de/fritzbox/
            while (true)
            {
                if (FWCheckEnabled)
                {
                    FtpDirectory CurrentScan;
                    using (FtpClient ftp = GetClient())
                    {
                        try
                        {
                            CurrentScan = RecurseFTP(ftp, "/fritz.box");
                        }
                        catch (Exception ex)
                        {
                            Log.Warning(ex, "Fehler beim FTP Scan");
                            await Task.Delay(FWCheckIntervall, token);

                            continue;
                        }
                    }
                    if (LastScan == null)
                    {
                        LastScan = CurrentScan;
                        await Task.Delay(FWCheckIntervall, token);

                        continue;
                    }

                    List <string> neu               = new List <string>();
                    List <string> gelöscht          = new List <string>();
                    List <string> geändert          = new List <string>();
                    var           joinedDirectories = LastScan.Folders.Flatten(x => x.Folders).FullOuterJoin(CurrentScan.Folders.Flatten(x => x.Folders), x => x.FullName, x => x.FullName, (o, c, _) => new { Original = o, Current = c });
                    foreach (var directory in joinedDirectories)
                    {
                        if (directory.Original == null) // Neuer Ordner
                        {
                            neu.Add("[" + directory.Current !.FullName + (directory.Current.Files.Any() ? "(" + directory.Current.Files.Select(x => x.Name).Join(", ") + ")]" : "]"));
                        }
                        else if (directory.Current == null) // Ordner gelöscht
                        {
                            gelöscht.Add("[" + directory.Original.FullName + (directory.Original.Files.Any() ? "(" + directory.Original.Files.Select(x => x.Name).Join(", ") + ")]" : "]"));
                        }
                        else
                        {
                            var           joinedFiles = directory.Original.Files.FullOuterJoin(directory.Current.Files, x => x.Name, x => x.Name, (o, c, _) => new { Original = o, Current = c });
                            List <string> fileChanges = new List <string>();
                            foreach (var file in joinedFiles)
                            {
                                if (file.Original == null) // Neue Datei
                                {
                                    fileChanges.Add(file.Current !.Name + "(neu)");
                                }
                                else if (file.Current == null) // Datei gelöscht
                                {
                                    fileChanges.Add(file.Original.Name + "(gelöscht)");
                                }
                                else if (file.Original.Modified != file.Current.Modified) // Datei geändert
                                {
                                    fileChanges.Add(file.Original.Name + "(" + file.Original.Modified.ToString() + "/" + file.Current.Modified.ToString() + ")");
                                }
                            }
                            if (fileChanges.Count > 0)
                            {
                                geändert.Add("[" + directory.Current.FullName + "(" + fileChanges.Join(", ") + ")]");
                            }
                        }
                    }

                    int summarizedCount = neu.Count + gelöscht.Count + geändert.Count;
                    if (summarizedCount > 20)
                    {
                        Log.Warning("{SummarizedCount} überschreitet limit an Änderungen, ignoriere...", summarizedCount);
                    }
                    else if (summarizedCount > 0)
                    {
                        string labors = "Änderungen auf dem FTP gesichtet! - ";
                        if (neu.Count > 0)
                        {
                            labors += "Neue { " + neu.Join(" ") + " } ";
                        }
                        if (gelöscht.Count > 0)
                        {
                            labors += "Gelöscht { " + gelöscht.Join(" ") + " } ";
                        }
                        if (geändert.Count > 0)
                        {
                            labors += "Geändert { " + geändert.Join(" ") + " } ";
                        }
                        labors = labors.TrimEnd() + " - Zum FTP: ftp://ftp.avm.de/fritz.box/";
                        ServerManager.AnnounceGlobal(labors);
                        NotifySubscribers(labors, neu.Concat(geändert).Select(x => BoxDatabase.GetShortName(x)).ToArray());
                    }
                    LastScan = CurrentScan;
                    await Task.Delay(FWCheckIntervall, token);
                }
                else
                {
                    await Task.Delay(30000, token);
                }
            }
        }