public IEnumerable <CounterRecord> RequestRecords(DateTime runDate, CounterReport report)
        {
            if (_arguments.JsonRepository != null)
            {
                using (IDirectoryRepository localJsonRepo = RepositoryFactory.CreateDirectoryRepository(_arguments.JsonRepository))
                {
                    List <DirectoryObjectMetadata> jsonFiles = localJsonRepo.ListFiles().ToList();

                    if (jsonFiles.Any(x => x.Name == $"{Name} {runDate:yyyy-MM-dd} {report}.json"))
                    {
                        DirectoryObjectMetadata directoryObjectMetadata = jsonFiles.First(x => x.Name == $"{Name} {runDate:yyyy-MM-dd} {report}.json");
                        using (Stream openFile = localJsonRepo.OpenFile(directoryObjectMetadata.Name))
                        {
                            string jsonString = new StreamReader(openFile).ReadToEnd();
                            foreach (var record in JsonConvert.DeserializeObject <IEnumerable <CounterRecord> >(jsonString))
                            {
                                yield return(record);
                            }
                        }

                        yield break;
                    }
                }
            }

            LogMessage($"Requesting {report.ToString()}");
            var reportItems = GetResponse(runDate, report.ToString());

            if (reportItems == null)
            {
                yield break;
            }

            foreach (IReportItem reportItem in reportItems)
            {
                if (reportItem.ItemDataType == Sushi.DataType.Platform && string.IsNullOrWhiteSpace(reportItem.ItemName))
                {
                    reportItem.ItemName = reportItem.ItemPublisher;
                }

                yield return(new CounterRecord
                {
                    ItemName = reportItem.ItemName,
                    ItemPlatform = reportItem.ItemPlatform,
                    ItemType = Convert(reportItem.ItemDataType),
                    RunDate = runDate,
                    Identifiers = reportItem.ItemIdentifier.Bind(a => a.Select(i => Convert(i, reportItem.ItemPlatform, reportItem.ItemDataType)).Where(i => i != null).ToArray(), new CounterIdentifier[] { }),
                    Metrics = reportItem.ItemPerformance.SelectMany(m => m.Instance).Select(i => new CounterMetric {
                        MetricType = Convert(i.MetricType), MetricValue = Int32.Parse(i.Count)
                    }).ToArray()
                });
            }
        }
Ejemplo n.º 2
0
        public override void Execute(DateTime runDate, Action <string> logMessage, CancellationToken cancellationToken)
        {
            using (IDirectoryRepository source = RepositoryFactory.CreateDirectoryRepository(sourceDirectory))
            {
                logMessage($"Connected to source repository '{source.Name}' ({source.ConnectionString})");

                using (IDirectoryRepository destination = RepositoryFactory.CreateDirectoryRepository(destinationDirectory))
                {
                    logMessage($"Connected to destination repository '{destination.Name}' ({destination.ConnectionString})");

                    Regex filePattern = new Regex(arguments.FilePattern, RegexOptions.IgnoreCase);
                    List <DirectoryObjectMetadata> destinationFiles = destination.ListFiles("/").ToList();
                    int newCount = 0, modified = 0;
                    foreach (DirectoryObjectMetadata file in source.ListFiles("/").Where(x => filePattern.IsMatch(x.Name)))
                    {
                        try
                        {
                            if (!destinationFiles.Select(x => x.Name).Contains(file.Name))
                            {
                                logMessage($"Processing {file.Name} from {source.Name} to {destination.Name}");

                                using (Stream destStream = destination.CreateFile("TMP" + file.Name, FileCreationMode.Overwrite))
                                {
                                    using (Stream sourceStream = source.OpenFile(file.Name))
                                    {
                                        sourceStream.CopyTo(destStream);
                                    }
                                }

                                destination.CopyFile("TMP" + file.Name, file.Name);
                                destination.DeleteFile("TMP" + file.Name);

                                logMessage($"Added {file.Name} from {source.Name} to {destination.Name}");
                                newCount++;

                                if (cancellationToken.IsCancellationRequested)
                                {
                                    source.Dispose();
                                    destination.Dispose();
                                    cancellationToken.ThrowIfCancellationRequested();
                                }
                            }
                            else
                            {
                                DirectoryObjectMetadata destinationFile = destinationFiles.Find(x => x.Name == file.Name);
                                if (file.ModifiedDate > destinationFile.ModifiedDate)
                                {
                                    logMessage($"Processing {file.Name} from {source.Name} to {destination.Name}");

                                    using (Stream destStream = destination.CreateFile("TMP" + file.Name, FileCreationMode.Overwrite))
                                    {
                                        using (Stream sourceStream = source.OpenFile(file.Name))
                                        {
                                            sourceStream.CopyTo(destStream);
                                        }
                                    }

                                    destination.DeleteFile(file.Name);
                                    destination.MoveFile("TMP" + file.Name, file.Name);

                                    logMessage($"Updated {file.Name} from {source.Name} to {destination.Name}");
                                    modified++;

                                    if (cancellationToken.IsCancellationRequested)
                                    {
                                        source.Dispose();
                                        destination.Dispose();
                                        cancellationToken.ThrowIfCancellationRequested();
                                    }
                                }
                            }
                        }
                        catch (Exception)
                        {
                            destination.DeleteFile("TMP" + file.Name);
                            throw;
                        }
                    }

                    logMessage($"Discovered {newCount} new files and {modified} updated files).");
                }
            }
        }