Пример #1
0
        public void ScheduleRefresh(ResourcePath path, IEnumerable <string> mediaCategories, bool includeSubDirectories)
        {
            ICollection <ImportJob> importJobs;

            lock (_syncObj)
                importJobs = new List <ImportJob>(_importJobs);
            ICollection <ImportJob> removeImportJobs = new List <ImportJob>();

            foreach (ImportJob checkJob in importJobs)
            {
                if (checkJob.BasePath.IsSameOrParentOf(path))
                {
                    // The new job is included in an already existing job - re-schedule existing job
                    path = checkJob.BasePath;
                    checkJob.Cancel();
                    removeImportJobs.Add(checkJob);
                }
                if (path.IsParentOf(checkJob.BasePath))
                { // The new job will include the old job
                    checkJob.Cancel();
                    removeImportJobs.Add(checkJob);
                }
            }
            lock (_syncObj)
                foreach (ImportJob removeJob in removeImportJobs)
                {
                    _importJobs.Remove(removeJob);
                }
            ICollection <Guid> metadataExtractorIds = GetMetadataExtractorIdsForMediaCategories(mediaCategories);
            ImportJob          job = new ImportJob(ImportJobType.Refresh, path, metadataExtractorIds, includeSubDirectories);

            EnqueueImportJob(job);
            ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportScheduled, path, ImportJobType.Refresh);
        }
Пример #2
0
        public void CancelJobsForPath(ResourcePath path)
        {
            ICollection <ImportJob> importJobs;

            lock (_syncObj)
                importJobs = new List <ImportJob>(_importJobs);
            ICollection <ImportJob> cancelImportJobs = new List <ImportJob>();

            foreach (ImportJob job in importJobs)
            {
                if (path.IsSameOrParentOf(job.BasePath))
                {
                    job.Cancel();
                    cancelImportJobs.Add(job);
                }
            }
            lock (_syncObj)
                foreach (ImportJob job in cancelImportJobs)
                {
                    if (_importJobs.Remove(job))
                    {
                        ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportScheduleCanceled, path);
                    }
                }
        }
Пример #3
0
        /// <summary>
        /// Imports the resource with the given <paramref name="mediaItemAccessor"/>.
        /// </summary>
        /// <remarks>
        /// This method will be called for file resources as well as for directory resources because some metadata extractors
        /// extract their metadata from directories.
        /// </remarks>
        /// <param name="mediaItemAccessor">File or directory resource to be imported.</param>
        /// <param name="parentDirectoryId">Media item id of the parent directory, if present, else <see cref="Guid.Empty"/>.</param>
        /// <param name="metadataExtractors">Collection of metadata extractors to apply to the given resoure.</param>
        /// <param name="resultHandler">Callback to notify the import results.</param>
        /// <param name="mediaAccessor">Convenience reference to the media accessor.</param>
        /// <returns><c>true</c>, if metadata could be extracted from the given <paramref name="mediaItemAccessor"/>, else
        /// <c>false</c>.</returns>
        protected bool ImportResource(ImportJob importJob, IResourceAccessor mediaItemAccessor, Guid parentDirectoryId, ICollection <IMetadataExtractor> metadataExtractors,
                                      IImportResultHandler resultHandler, IMediaAccessor mediaAccessor)
        {
            const bool   forceQuickMode = false; // Allow extractions with probably longer runtime.
            ResourcePath path           = mediaItemAccessor.CanonicalLocalResourcePath;

            ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStatus, path);
            IDictionary <Guid, IList <MediaItemAspect> > aspects = mediaAccessor.ExtractMetadataAsync(mediaItemAccessor, metadataExtractors, forceQuickMode).Result;

            if (aspects == null)
            {
                // No metadata could be extracted
                return(false);
            }
            using (CancellationTokenSource cancelToken = new CancellationTokenSource())
            {
                try
                {
                    resultHandler.UpdateMediaItemAsync(parentDirectoryId, path, MediaItemAspect.GetAspects(aspects), importJob.JobType == ImportJobType.Refresh, importJob.BasePath);
                    resultHandler.DeleteUnderPathAsync(path);
                }
                catch
                {
                    cancelToken.Cancel();
                    throw;
                }
            }
            return(true);
        }
Пример #4
0
 private void OnMessageReceived(AsynchronousMessageQueue queue, SystemMessage message)
 {
     if (message.ChannelName == SystemMessaging.CHANNEL)
     {
         SystemMessaging.MessageType messageType = (SystemMessaging.MessageType)message.MessageType;
         switch (messageType)
         {
         case SystemMessaging.MessageType.SystemStateChanged:
             SystemState newState = (SystemState)message.MessageData[SystemMessaging.NEW_STATE];
             if (newState == SystemState.ShuttingDown)
             {
                 IsSuspended = true;
             }
             break;
         }
     }
     if (message.ChannelName == TaskSchedulerMessaging.CHANNEL)
     {
         TaskSchedulerMessaging.MessageType messageType = (TaskSchedulerMessaging.MessageType)message.MessageType;
         switch (messageType)
         {
         case TaskSchedulerMessaging.MessageType.DUE:
             Task dueTask = (Task)message.MessageData[TaskSchedulerMessaging.TASK];
             if (dueTask.ID == _importerTaskId)
             {
                 // Forward a new message which will be handled by MediaLibrary (it knows the shares and configuration), then it will
                 // schedule the local shares.
                 ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.RefreshLocalShares);
             }
             break;
         }
     }
 }
Пример #5
0
 /// <summary>
 /// Activates the ImportJob
 /// </summary>
 /// <param name="mediaBrowsingCallback"></param>
 /// <param name="importResultHandler"></param>
 public void Activate(IMediaBrowsing mediaBrowsingCallback, IImportResultHandler importResultHandler)
 {
     // To avoid peaks on system startup we start one Block every 100ms.
     // Currently we also need this because the MediaAccessor is not threadsafe on startup
     // see here: http://forum.team-mediaportal.com/threads/mediaaccessor-not-thread-safe.125132/
     // ToDo: Make MediaAccessor threadsafe on startup
     foreach (var block in _dataflowBlocks)
     {
         block.Activate(mediaBrowsingCallback, importResultHandler);
         Task.Delay(100).Wait();
     }
     ServiceRegistration.Get <ILogger>().Info("ImporterWorker.{0}: Activated", this);
     ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStarted, _importJobInformation.BasePath);
 }
        private void DoScheduleImport(ImportJobInformation importJobInformation)
        {
            if (_status == Status.Shutdown)
            {
                ServiceRegistration.Get <ILogger>().Error("ImporterWorker: Scheduling of an ImportJob was requested although status was neither 'Activated' nor 'Suspended' but 'Shutdown'");
                return;
            }

            // For now we always set this to active to make it look like the old ImporterWorker
            // ToDo: Remove this and all usages of ImportJobInformation.State
            importJobInformation.State = ImportJobState.Active;

            // if the ImportJob to be scheduled is the same as or contains an
            // already running ImportJob, cancel the already running ImportJob
            // and schedule this one
            var jobsToBeCancelled = new HashSet <ImportJobController>();

            foreach (var kvp in _importJobControllers)
            {
                if (importJobInformation >= kvp.Key)
                {
                    ServiceRegistration.Get <ILogger>().Info("ImporterWorker: {0} is contained in or the same as the ImportJob which is currently being scheduled. Canceling {1}", kvp.Value, kvp.Value);
                    kvp.Value.Cancel();
                    jobsToBeCancelled.Add(kvp.Value);
                }
            }
            // We need to wait here until the canceled ImportJobs are removed from _importJobControllers
            // otherwise we run into trouble when the ImportJobs equal each other because then they
            // have the same key in _importJobControllers.
            Task.WhenAll(jobsToBeCancelled.Select(controller => controller.Completion)).Wait();
            foreach (var controller in jobsToBeCancelled)
            {
                controller.Dispose();
            }

            //Set updated media items to changed
            _mediaBrowsing?.MarkUpdatableMediaItems();

            var importJobController = new ImportJobController(new ImportJobNewGen(importJobInformation, null), Interlocked.Increment(ref _numberOfLastImportJob), this);

            _importJobControllers[importJobInformation] = importJobController;

            ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Scheduled {0} ({1}) (Path ='{2}', ImportJobType='{3}', IncludeSubdirectories='{4}')", importJobController, _status, importJobInformation.BasePath, importJobInformation.JobType, importJobInformation.IncludeSubDirectories);
            ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportScheduled, importJobInformation.BasePath, importJobInformation.JobType);

            if (_status == Status.Activated)
            {
                importJobController.Activate(_mediaBrowsing, _importResultHandler);
            }
        }
Пример #7
0
        /// <summary>
        /// Imports the resource with the given <paramref name="mediaItemAccessor"/>.
        /// </summary>
        /// <remarks>
        /// This method will be called for file resources as well as for directory resources because some metadata extractors
        /// extract their metadata from directories.
        /// </remarks>
        /// <param name="mediaItemAccessor">File or directory resource to be imported.</param>
        /// <param name="parentDirectoryId">Media item id of the parent directory, if present, else <see cref="Guid.Empty"/>.</param>
        /// <param name="metadataExtractors">Collection of metadata extractors to apply to the given resoure.</param>
        /// <param name="resultHandler">Callback to notify the import results.</param>
        /// <param name="mediaAccessor">Convenience reference to the media accessor.</param>
        /// <returns><c>true</c>, if metadata could be extracted from the given <paramref name="mediaItemAccessor"/>, else
        /// <c>false</c>.</returns>
        protected bool ImportResource(IResourceAccessor mediaItemAccessor, Guid parentDirectoryId,
                                      ICollection <IMetadataExtractor> metadataExtractors, IImportResultHandler resultHandler, IMediaAccessor mediaAccessor)
        {
            const bool   forceQuickMode = false; // Allow extractions with probably longer runtime.
            ResourcePath path           = mediaItemAccessor.CanonicalLocalResourcePath;

            ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStatus, path);
            IDictionary <Guid, MediaItemAspect> aspects = mediaAccessor.ExtractMetadata(mediaItemAccessor, metadataExtractors, forceQuickMode);

            if (aspects == null)
            {
                // No metadata could be extracted
                return(false);
            }
            resultHandler.UpdateMediaItem(parentDirectoryId, path, aspects.Values);
            resultHandler.DeleteUnderPath(path);
            return(true);
        }
Пример #8
0
        private void OnFinished(Task previousTask)
        {
            // Do not notify about progress anymore for every disposed PendingImportResource
            _notifyProgress = false;

            if (_pendingImportResources.Count > 0)
            {
                // The ImportJob has finished, but we have PendingImportJobResources left that have not been disposed.
                // This should only happen when the ImportJob finishes in cancelled oder faulted state. When the ImportJob
                // ran to completion, the DataflowBlocks should have disposed all the PendingImportResources.
                if (!previousTask.IsCanceled && !previousTask.IsFaulted)
                {
                    ServiceRegistration.Get <ILogger>().Warn("ImporterWorker.{0}: The ImportJob ran to completion but there are {1} undisposed PendingImportResources left. Disposing them now...", this, _pendingImportResources.Count);
                }
            }

            if (previousTask.IsFaulted)
            {
                ServiceRegistration.Get <ILogger>().Error("ImporterWorker.{0}: Error while processing", previousTask.Exception, this);
            }
            else if (previousTask.IsCanceled)
            {
                ServiceRegistration.Get <ILogger>().Info("ImporterWorker.{0}: Canceled", this);
            }
            else
            {
                ServiceRegistration.Get <ILogger>().Info("ImporterWorker.{0}: Completed", this);
            }

            // When this ImportJob was cancelled it needs to be disposed manually.
            if (!previousTask.IsCanceled)
            {
                Dispose();
            }

            ImporterWorkerMessaging.SendImportMessage(previousTask.IsCanceled ? ImporterWorkerMessaging.MessageType.ImportScheduleCanceled : ImporterWorkerMessaging.MessageType.ImportCompleted, _importJobInformation.BasePath);
            _parentImporterWorker.NotifyProgress(true);

            // If this ImportJob faulted or was cancelled we can't do anything but log it (which we do above).
            // Therefore the Completion Task of this ImportJobController always returns 'RunToCompletion' to
            // avoid exceptions being thrown when this Task is awaited.
            _importJobControllerCompletion.SetResult(null);
        }
Пример #9
0
        public void ScheduleImport(ResourcePath path, IEnumerable <string> mediaCategories, bool includeSubDirectories)
        {
            ICollection <ImportJob> importJobs;

            lock (_syncObj)
                importJobs = new List <ImportJob>(_importJobs);
            if (importJobs.Any(checkJob => checkJob.JobType == ImportJobType.Import && checkJob.BasePath.IsSameOrParentOf(path)))
            {
                // Path is already being scheduled as Import job
                // => the new job is already included in an already existing job
                return;
            }
            CancelJobsForPath(path);
            ICollection <Guid> metadataExtractorIds = GetMetadataExtractorIdsForMediaCategories(mediaCategories);
            ImportJob          job = new ImportJob(ImportJobType.Import, path, metadataExtractorIds, includeSubDirectories);

            EnqueueImportJob(job);
            ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportScheduled, path, ImportJobType.Import);
        }
Пример #10
0
        /// <summary>
        /// Executes the given <paramref name="importJob"/>.
        /// </summary>
        /// <remarks>
        /// This method automatically terminates if it encounters that this importer worker was suspended or that the
        /// given <paramref name="importJob"/> was cancelled.
        /// </remarks>
        /// <param name="importJob">Import job to be executed. The state variables of this parameter will be updated by
        /// this method.</param>
        protected void Process(ImportJob importJob)
        {
            ImportJobState state = importJob.State;

            if (state == ImportJobState.Finished || state == ImportJobState.Cancelled || state == ImportJobState.Erroneous)
            {
                return;
            }

            // Preparation
            IMediaAccessor       mediaAccessor = ServiceRegistration.Get <IMediaAccessor>();
            IImportResultHandler resultHandler;
            IMediaBrowsing       mediaBrowsing;

            lock (_syncObj)
            {
                resultHandler = _importResultHandler;
                mediaBrowsing = _mediaBrowsingCallback;
            }
            if (mediaBrowsing == null || resultHandler == null)
            {
                // Can be the case if this importer worker was asynchronously suspended
                return;
            }
            try
            {
                try
                {
                    ICollection <IMetadataExtractor> metadataExtractors = new List <IMetadataExtractor>();
                    foreach (Guid metadataExtractorId in importJob.MetadataExtractorIds)
                    {
                        IMetadataExtractor extractor;
                        if (!mediaAccessor.LocalMetadataExtractors.TryGetValue(metadataExtractorId, out extractor))
                        {
                            continue;
                        }
                        metadataExtractors.Add(extractor);
                    }

                    // Prepare import
                    if (state == ImportJobState.Scheduled)
                    {
                        ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Starting import job '{0}'", importJob);
                        ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStarted, importJob.BasePath);
                        IResourceAccessor ra;
                        if (!importJob.BasePath.TryCreateLocalResourceAccessor(out ra))
                        {
                            throw new ArgumentException(string.Format("Unable to access resource path '{0}'", importJob.BasePath));
                        }
                        using (ra)
                        {
                            IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor;
                            if (fsra != null)
                            { // Prepare complex import process
                                importJob.PendingResources.Add(new PendingImportResource(Guid.Empty, (IFileSystemResourceAccessor)fsra.Clone()));
                                importJob.State = ImportJobState.Active;
                            }
                            else
                            { // Simple resource import
                                ImportSingleFile(importJob, ra, metadataExtractors, mediaBrowsing, resultHandler, mediaAccessor);
                                lock (importJob.SyncObj)
                                    if (importJob.State == ImportJobState.Active)
                                    {
                                        importJob.State = ImportJobState.Finished;
                                    }
                                return;
                            }
                        }
                    }
                    else
                    {
                        ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Resuming import job '{0}' ({1} items pending)", importJob, importJob.PendingResources.Count);
                    }

                    // Actual import process
                    while (importJob.HasPendingResources)
                    {
                        Thread.Sleep(0);
                        CheckImportStillRunning(importJob.State);
                        PendingImportResource pendingImportResource;
                        lock (importJob.SyncObj)
                            pendingImportResource = importJob.PendingResources.FirstOrDefault();
                        if (pendingImportResource.IsValid)
                        {
                            IFileSystemResourceAccessor fsra = pendingImportResource.ResourceAccessor;
                            int    numPending    = importJob.PendingResources.Count;
                            string moreResources = numPending > 1 ? string.Format(" ({0} more resources pending)", numPending) : string.Empty;
                            ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Importing '{0}'{1}", fsra.ResourcePathName, moreResources);
                            if (fsra.IsFile && fsra.Exists)
                            {
                                ImportResource(importJob, fsra, pendingImportResource.ParentDirectory, metadataExtractors, resultHandler, mediaAccessor);
                            }
                            else if (!fsra.IsFile)
                            {
                                CheckImportStillRunning(importJob.State);
                                Guid?currentDirectoryId = ImportDirectory(importJob, pendingImportResource.ParentDirectory, fsra, metadataExtractors,
                                                                          mediaBrowsing, resultHandler, mediaAccessor);
                                CheckImportStillRunning(importJob.State);
                                if (currentDirectoryId.HasValue && importJob.IncludeSubDirectories)
                                {
                                    // Add subdirectories in front of work queue
                                    lock (importJob.SyncObj)
                                    {
                                        ICollection <IFileSystemResourceAccessor> directories = FileSystemResourceNavigator.GetChildDirectories(fsra, false);
                                        if (directories != null)
                                        {
                                            foreach (IFileSystemResourceAccessor childDirectory in directories)
                                            {
                                                importJob.PendingResources.Insert(0, new PendingImportResource(currentDirectoryId.Value, childDirectory));
                                            }
                                        }
                                    }
                                }
                            }
                            else
                            {
                                ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Cannot import resource '{0}': It's neither a file nor a directory", fsra.CanonicalLocalResourcePath.Serialize());
                            }
                        }
                        lock (importJob.SyncObj)
                            importJob.PendingResources.Remove(pendingImportResource);
                        pendingImportResource.Dispose();
                    }
                    lock (importJob.SyncObj)
                        if (importJob.State == ImportJobState.Active)
                        {
                            importJob.State = ImportJobState.Finished;
                        }
                    ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Finished import job '{0}'", importJob);
                    ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportCompleted, importJob.BasePath);
                }
                catch (Exception e)
                {
                    CheckSuspended(e); // Throw ImportAbortException if suspended - will skip warning and tagging job as erroneous
                    ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem processing '{0}'", e, importJob);
                    ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportCompleted, importJob.BasePath);
                    importJob.State = ImportJobState.Erroneous;
                }
            }
            catch (ImportSuspendedException)
            {
                ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Suspending import job '{0}' ({1} items pending - will be continued next time)", importJob, importJob.PendingResources.Count);
            }
            catch (ImportAbortException)
            {
                ServiceRegistration.Get <ILogger>().Info("ImporterWorker: Aborting import job '{0}' ({1} items pending)", importJob, importJob.PendingResources.Count);
            }
        }
Пример #11
0
        /// <summary>
        /// Imports or refreshes the directory with the specified <paramref name="directoryAccessor"/>. Sub directories will not
        /// be processed in this method.
        /// </summary>
        /// <param name="importJob">The import job being processed.</param>
        /// <param name="parentDirectoryId">Media item id of the parent directory, if present, else <see cref="Guid.Empty"/>.</param>
        /// <param name="directoryAccessor">Resource accessor for the directory to import.</param>
        /// <param name="metadataExtractors">Metadata extractors to apply on the resources.</param>
        /// <param name="mediaBrowsing">Callback interface to the media library for the refresh import type.</param>
        /// <param name="resultHandler">Callback to notify the import result.</param>
        /// <param name="mediaAccessor">Convenience reference to the media accessor.</param>
        /// <returns>Id of the directory's media item or <c>null</c>, if the given <paramref name="directoryAccessor"/>
        /// was imported as a media item or if an error occured. If <c>null</c> is returned, the directory import should be
        /// considered to be finished.</returns>
        protected Guid?ImportDirectory(ImportJob importJob, Guid parentDirectoryId, IFileSystemResourceAccessor directoryAccessor,
                                       ICollection <IMetadataExtractor> metadataExtractors, IMediaBrowsing mediaBrowsing,
                                       IImportResultHandler resultHandler, IMediaAccessor mediaAccessor)
        {
            ResourcePath currentDirectoryPath = directoryAccessor.CanonicalLocalResourcePath;

            try
            {
                ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportStatus, currentDirectoryPath);
                if (ImportResource(importJob, directoryAccessor, parentDirectoryId, metadataExtractors, resultHandler, mediaAccessor))
                {
                    // The directory could be imported as a media item.
                    // If the directory itself was identified as a normal media item, don't import its children.
                    // Necessary for DVD directories, for example.
                    return(null);
                }
                Guid directoryId = GetOrAddDirectory(importJob, directoryAccessor, parentDirectoryId, mediaBrowsing, resultHandler);
                IDictionary <string, MediaItem> path2Item = new Dictionary <string, MediaItem>();
                if (importJob.JobType == ImportJobType.Refresh)
                {
                    foreach (MediaItem mediaItem in mediaBrowsing.BrowseAsync(directoryId,
                                                                              IMPORTER_PROVIDER_MIA_ID_ENUMERATION, EMPTY_MIA_ID_ENUMERATION, null, false).Result)
                    {
                        IList <MultipleMediaItemAspect> providerResourceAspects;
                        if (MediaItemAspect.TryGetAspects(mediaItem.Aspects, ProviderResourceAspect.Metadata, out providerResourceAspects))
                        {
                            path2Item[providerResourceAspects[0].GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH)] = mediaItem;
                        }
                    }
                }
                CheckImportStillRunning(importJob.State);
                ICollection <IFileSystemResourceAccessor> files = FileSystemResourceNavigator.GetFiles(directoryAccessor, false);
                if (files != null)
                {
                    foreach (IFileSystemResourceAccessor fileAccessor in files)
                    {
                        using (fileAccessor)
                        { // Add & update files
                            ResourcePath currentFilePath    = fileAccessor.CanonicalLocalResourcePath;
                            string       serializedFilePath = currentFilePath.Serialize();
                            try
                            {
                                SingleMediaItemAspect importerAspect;
                                MediaItem             mediaItem;
                                if (importJob.JobType == ImportJobType.Refresh &&
                                    path2Item.TryGetValue(serializedFilePath, out mediaItem) &&
                                    MediaItemAspect.TryGetAspect(mediaItem.Aspects, ImporterAspect.Metadata, out importerAspect) &&
                                    importerAspect.GetAttributeValue <DateTime>(ImporterAspect.ATTR_LAST_IMPORT_DATE) > fileAccessor.LastChanged)
                                { // We can skip this file; it was imported after the last change time of the item
                                    path2Item.Remove(serializedFilePath);
                                    continue;
                                }
                                if (ImportResource(importJob, fileAccessor, directoryId, metadataExtractors, resultHandler, mediaAccessor))
                                {
                                    path2Item.Remove(serializedFilePath);
                                }
                            }
                            catch (Exception e)
                            {
                                CheckSuspended(e); // Throw ImportAbortException if suspended - will skip warning and tagging job as erroneous
                                ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem while importing resource '{0}'", e, serializedFilePath);
                                importJob.State = ImportJobState.Erroneous;
                            }
                            CheckImportStillRunning(importJob.State);
                        }
                    }
                }
                if (importJob.JobType == ImportJobType.Refresh)
                { // Remove remaining (= non-present) files
                    foreach (string pathStr in path2Item.Keys)
                    {
                        ResourcePath path = ResourcePath.Deserialize(pathStr);
                        try
                        {
                            IResourceAccessor ra;
                            if (!path.TryCreateLocalResourceAccessor(out ra))
                            {
                                throw new IllegalCallException("Unable to access resource path '{0}'", importJob.BasePath);
                            }
                            using (ra)
                            {
                                IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor;
                                if (fsra == null || !fsra.IsFile)
                                {
                                    // Don't touch directories because they will be imported in a different call of ImportDirectory
                                    continue;
                                }
                            }
                        }
                        catch (IllegalCallException)
                        {
                            // This happens if the resource doesn't exist any more - we also catch missing directories here
                        }
                        // Delete all remaining items
                        resultHandler.DeleteMediaItemAsync(path);
                        CheckImportStillRunning(importJob.State);
                    }
                }
                return(directoryId);
            }
            catch (ImportSuspendedException)
            {
                throw;
            }
            catch (ImportAbortException)
            {
                throw;
            }
            catch (UnauthorizedAccessException e)
            {
                // If the access to the file or folder was denied, simply continue with the others
                ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem accessing resource '{0}', continueing with one", e, currentDirectoryPath);
            }
            catch (Exception e)
            {
                CheckSuspended(e); // Throw ImportAbortException if suspended - will skip warning and tagging job as erroneous
                ServiceRegistration.Get <ILogger>().Warn("ImporterWorker: Problem while importing directory '{0}'", e, currentDirectoryPath);
                importJob.State = ImportJobState.Erroneous;
            }
            return(null);
        }
Пример #12
0
 private void SendProgressNotificationMessage()
 {
     ImporterWorkerMessaging.SendImportMessage(ImporterWorkerMessaging.MessageType.ImportProgress, _importJobControllers.ToDictionary(kvp => kvp.Key, kvp => kvp.Value.Progress));
 }