Esempio n. 1
0
 private void ExecuteProcedureWithProgress(ProcedureType procedureType, Action action)
 {
     if (this.IsStopRequested)
     {
         Tracer.TraceInformation("ProgressController.ExecuteProcedureWithProgress: Stop requested. Procedure type: {0}", new object[]
         {
             procedureType
         });
         return;
     }
     try
     {
         if (this.StatusManager.BeginProcedure(procedureType))
         {
             ScenarioData scenarioData = ScenarioData.Current;
             Task         task         = Task.Factory.StartNew(delegate()
             {
                 ScenarioData scenarioData;
                 using (new ScenarioData(scenarioData))
                 {
                     this.WaitForAndProcessProgress();
                 }
             });
             Exception ex = null;
             try
             {
                 action();
             }
             finally
             {
                 this.progressAvailable.Release(1);
                 ex = AsynchronousTaskHandler.WaitForAsynchronousTask(task);
             }
             if (ex != null)
             {
                 Tracer.TraceError("ProgressController.ExecuteProcedureWithProgress: Hitting exception in progress task. Exception: {0}", new object[]
                 {
                     ex
                 });
                 throw ex;
             }
         }
     }
     finally
     {
         this.StatusManager.EndProcedure();
     }
 }
Esempio n. 2
0
		public void WriteDataBatchItemListGen(object sender, DataBatchEventArgs<ItemListGenerator.ItemIdsDataBatch> args)
		{
			ScenarioData scenarioData = ScenarioData.Current;
			ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
			this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
			{
				ScenarioData scenarioData;
				using (new ScenarioData(scenarioData))
				{
					this.WriteDataBatch((ItemListGenerator.ItemIdsDataBatch)dataBatch);
				}
			}, args.DataBatch));
			if (ex != null)
			{
				throw ex;
			}
		}
        private void WriteDataBatch(object sender, DataBatchEventArgs <T> args)
        {
            ScenarioData    scenarioData = ScenarioData.Current;
            ExportException ex           = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);

            this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
            {
                ScenarioData scenarioData;
                using (new ScenarioData(scenarioData))
                {
                    this.batchDataWriter.WriteDataBatch((T)((object)dataBatch));
                }
            }, args.DataBatch));
            if (ex != null)
            {
                throw ex;
            }
        }
        public void Execute()
        {
            ExportException ex = null;

            try
            {
                this.batchDataReader.StartReading();
            }
            finally
            {
                ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
                this.writingTask = null;
            }
            if (ex != null)
            {
                throw ex;
            }
        }
Esempio n. 5
0
		public void WriteDataBatchDataRetriever(object sender, DataBatchEventArgs<List<ItemInformation>> args)
		{
			if (this.DataRetriever == null || this.DataRetriever.DataWriter == null)
			{
				return;
			}
			ScenarioData scenarioData = ScenarioData.Current;
			ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
			this.writingTask = ((ex != null || args.DataBatch == null) ? null : Task.Factory.StartNew(delegate(object dataBatch)
			{
				ScenarioData scenarioData;
				using (new ScenarioData(scenarioData))
				{
					this.DataRetriever.DataWriter.WriteDataBatch((List<ItemInformation>)dataBatch);
				}
			}, args.DataBatch));
			if (ex != null)
			{
				throw ex;
			}
		}
Esempio n. 6
0
        private void ExportSourceMailbox(IContextualBatchDataWriter <List <ItemInformation> > dataWriter, SourceInformation source, bool isUnsearchable)
        {
            Tracer.TraceInformation("ProgressController.ExportSourceMailbox: Source Id: {0}; isUnsearchable: {1}", new object[]
            {
                source.Configuration.Id,
                isUnsearchable
            });
            this.ItemListGenerator.DoUnSearchable = isUnsearchable;
            bool flag = (!isUnsearchable && source.Status.ItemCount <= 0) || (isUnsearchable && source.Status.UnsearchableItemCount <= 0);

            if ((!isUnsearchable && source.Status.ItemCount > source.Status.ProcessedItemCount) || (isUnsearchable && source.Status.UnsearchableItemCount > source.Status.ProcessedUnsearchableItemCount) || !this.target.ExportContext.IsResume || flag)
            {
                IItemIdList   itemIdList    = this.target.CreateItemIdList(source.Configuration.Id, isUnsearchable);
                DataContext   dataContext   = new DataContext(source, itemIdList);
                DataRetriever dataRetriever = new DataRetriever(dataContext, this);
                dataRetriever.DataWriter              = dataWriter;
                this.ItemListGenerator.DataRetriever  = dataRetriever;
                this.ItemListGenerator.DataBatchRead += this.ItemListGenerator.WriteDataBatchItemListGen;
                dataRetriever.DataBatchRead          += this.ItemListGenerator.WriteDataBatchDataRetriever;
                ExportException ex = null;
                try
                {
                    this.ItemListGenerator.DoExportForSourceMailbox(dataRetriever.DataContext.SourceInformation);
                }
                finally
                {
                    ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.ItemListGenerator.WritingTask);
                    this.ItemListGenerator.WritingTask   = null;
                    this.ItemListGenerator.DataRetriever = null;
                }
                if (ex != null)
                {
                    throw ex;
                }
            }
        }
 private void ReaderAborting(object sender, EventArgs args)
 {
     AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
     this.writingTask = null;
 }
Esempio n. 8
0
		public void DoExportForSourceMailbox(SourceInformation sourceMailbox)
		{
			Tracer.TraceInformation("ItemListGenerator.DoExportForSourceMailbox: Generating item list for mailbox '{0}'", new object[]
			{
				sourceMailbox.Configuration.Id
			});
			ErrorRecord errorRecord = null;
			sourceMailbox.Configuration.Id.StartsWith("\\");
			ScenarioData.Current["PM"] = sourceMailbox.Configuration.LegacyExchangeDN.GetHashCode().ToString();
			if (sourceMailbox.Status.ItemCount < 0)
			{
				sourceMailbox.Status.ItemCount = 0;
			}
			if (sourceMailbox.Status.UnsearchableItemCount < 0)
			{
				sourceMailbox.Status.UnsearchableItemCount = 0;
			}
			try
			{
				bool flag = this.target.ExportContext.ExportMetadata.IncludeSearchableItems && !this.DoUnSearchable;
				bool flag2 = this.target.ExportContext.ExportMetadata.IncludeUnsearchableItems && this.DoUnSearchable;
				bool flag3 = false;
				Dictionary<string, string> dictionary = null;
				dictionary = ItemListGenerator.PrepareAllFolders(sourceMailbox.ServiceClient, sourceMailbox.Configuration.Id);
				if (flag)
				{
					bool errorHappened = false;
					try
					{
						bool flag4 = false;
						Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer for primary for mailbox: '{0}'", new object[]
						{
							sourceMailbox.Configuration.Id
						});
						this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, !flag, false, ref flag4, out flag3);
						if (dictionary != null && dictionary.Values.Contains("\\archive"))
						{
							Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer for archive for mailbox: '{0}'", new object[]
							{
								sourceMailbox.Configuration.Id
							});
							this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, !flag, true, ref flag4, out flag3);
						}
						ExportException ex = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
						if (ex != null)
						{
							errorHappened = true;
							throw ex;
						}
					}
					finally
					{
						this.DataRetriever.DataWriter.ExitDataContext(errorHappened);
					}
				}
				bool isUnsearchable = true;
				if (flag2)
				{
					bool errorHappened2 = false;
					try
					{
						bool flag5 = false;
						Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for primary for mailbox: '{0}'", new object[]
						{
							sourceMailbox.Configuration.Id
						});
						this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, isUnsearchable, false, ref flag5, out flag3);
						if (!flag3)
						{
							Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for newschemafailed for mailbox: '{0}'", new object[]
							{
								sourceMailbox.Configuration.Id
							});
							this.GetAllItemIdsFromServer<UnsearchableItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<UnsearchableItemId>(this.GetUnsearchableItemIdPageFromServer), dictionary, isUnsearchable, false, ref flag5, out flag3);
						}
						else if (dictionary != null && dictionary.Values.Contains("\\archive"))
						{
							Tracer.TraceInformation("ItemListGenerator.GenerateItemListForSourceMailbox: call GetAllItemIdsFromServer isunsearchable for archive for mailbox: '{0}'", new object[]
							{
								sourceMailbox.Configuration.Id
							});
							this.GetAllItemIdsFromServer<ItemId>(sourceMailbox, new ItemListGenerator.GetItemIdPageFromServerDelegate<ItemId>(this.GetItemIdPageFromServer), dictionary, isUnsearchable, true, ref flag5, out flag3);
						}
						ExportException ex2 = AsynchronousTaskHandler.WaitForAsynchronousTask(this.writingTask);
						if (ex2 != null)
						{
							errorHappened2 = true;
							throw ex2;
						}
					}
					finally
					{
						this.DataRetriever.DataWriter.ExitDataContext(errorHappened2);
					}
				}
			}
			catch (ExportException ex3)
			{
				Tracer.TraceInformation("ItemListGenerator.DoExportForSourceMailbox: Error for mailbox '{0}'. Exception: {1}", new object[]
				{
					sourceMailbox.Configuration.Id,
					ex3
				});
				errorRecord = new ErrorRecord
				{
					SourceId = sourceMailbox.Configuration.Id,
					Item = null,
					ErrorType = ex3.ErrorType,
					DiagnosticMessage = ex3.Message,
					Time = DateTime.UtcNow
				};
			}
			if (ScenarioData.Current.ContainsKey("PM"))
			{
				ScenarioData.Current.Remove("PM");
			}
			if (errorRecord != null)
			{
				this.AbortForSourceMailbox(errorRecord);
			}
		}