Example #1
0
        public async Task <IEnumerable <MediaSourceInfo> > GetMediaSources(IHasMediaSources item, CancellationToken cancellationToken)
        {
            var jobItemResult = _syncManager.GetJobItems(new SyncJobItemQuery
            {
                AddMetadata = false,
                Statuses    = new[] { SyncJobItemStatus.Synced },
                ItemId      = item.Id.ToString("N")
            });

            var list = new List <MediaSourceInfo>();

            if (jobItemResult.Items.Length > 0)
            {
                var targets = _syncManager.ServerSyncProviders
                              .SelectMany(i => i.GetAllSyncTargets().Select(t => new Tuple <IServerSyncProvider, SyncTarget>(i, t)))
                              .ToList();

                var serverId = _appHost.SystemId;

                foreach (var jobItem in jobItemResult.Items)
                {
                    var targetTuple = targets.FirstOrDefault(i => string.Equals(i.Item2.Id, jobItem.TargetId, StringComparison.OrdinalIgnoreCase));

                    if (targetTuple != null)
                    {
                        var syncTarget   = targetTuple.Item2;
                        var syncProvider = targetTuple.Item1;
                        var dataProvider = _syncManager.GetDataProvider(targetTuple.Item1, syncTarget);

                        var localItems = await dataProvider.GetItems(syncTarget, serverId, item.Id.ToString("N")).ConfigureAwait(false);

                        foreach (var localItem in localItems)
                        {
                            foreach (var mediaSource in localItem.Item.MediaSources)
                            {
                                AddMediaSource(list, localItem, mediaSource, syncProvider, syncTarget);
                            }
                        }
                    }
                }
            }

            return(list);
        }
Example #2
0
        public async Task Sync(IEnumerable <IServerSyncProvider> providers, IProgress <double> progress, CancellationToken cancellationToken)
        {
            var targets = providers
                          .SelectMany(i => i.GetAllSyncTargets().Select(t => new Tuple <IServerSyncProvider, SyncTarget>(i, t)))
                          .ToList();

            var    numComplete     = 0;
            double startingPercent = 0;
            double percentPerItem  = 1;

            if (targets.Count > 0)
            {
                percentPerItem /= targets.Count;
            }

            foreach (var target in targets)
            {
                cancellationToken.ThrowIfCancellationRequested();

                var currentPercent = startingPercent;
                var innerProgress  = new ActionableProgress <double>();
                innerProgress.RegisterAction(pct =>
                {
                    var totalProgress = pct * percentPerItem;
                    totalProgress    += currentPercent;
                    progress.Report(totalProgress);
                });

                var dataProvider = _syncManager.GetDataProvider(target.Item1, target.Item2);

                await new MediaSync(_logger, _syncManager, _appHost, _fileSystem, _config, _cryptographyProvider)
                .Sync(target.Item1, dataProvider, target.Item2, innerProgress, cancellationToken)
                .ConfigureAwait(false);

                numComplete++;
                startingPercent  = numComplete;
                startingPercent /= targets.Count;
                startingPercent *= 100;
                progress.Report(startingPercent);
            }
        }