private void FlushGroupList()
{
IAsyncProcessor ap = Core.ResourceAP;
if (!ap.IsOwnerThread)
{
ap.QueueJob(_priority, _flushGroupListDelegate);
}
else
{
_groupListLock.Enter();
try
{
foreach (string group in _groupList)
{
_serverResource.AddGroup(group);
}
_groupList.Clear();
}
finally
{
_groupListLock.Exit();
}
}
}
private static Task <IList <TOutput> > InvokeAsync <TInput, TOutput>(IAsyncProcessor <TInput, TOutput> processor, IList <TInput> input)
{
var result = processor.ToListAsync();
input.ToObservable().Subscribe(processor);
return(result);
}
public static void OwnerThread(IAsyncProcessor asyncProcessor)
{
if (!asyncProcessor.IsOwnerThread)
{
throw new InvalidOperationException("The method must be called from the " + ((AsyncProcessor)asyncProcessor).ThreadName + " thread");
}
}
protected EventSetStorageProcessorTest(EventSetStorageProcessor.IFactory storageProcessorFactory)
{
criticalEvent = new EventDetails
{
Category = EventTypeCategory.OemEvent,
EventTypeId = 1,
ResourceCategory = 2,
ResourceId = 3,
ReadTime = currentTime,
SiteId = 12
};
informationalEvent = new EventDetails
{
Category = EventTypeCategory.OemEvent,
EventTypeId = 2,
ResourceCategory = 2,
ResourceId = 3,
ReadTime = currentTime,
SiteId = 12
};
SetupConfigurationMock();
storageProcessor = storageProcessorFactory.CreateStorageProcessor(
() => repositoryMock.Object,
identityManagementServiceMock.Object,
processTypeManagerMock.Object,
configurationMock.Object,
() => currentTime);
}
public ParallelProcessor(
IAsyncProcessor asyncProcessor,
SegmentalCompressionConfiguration configuration)
{
this.asyncProcessor = asyncProcessor;
this.configuration = configuration;
this.asyncProcessor.ProcessingEnded += AsyncProcessor_ProcessingEnded;
}
private static IEnumerator ProcessAsync(IAsyncProcessor processor)
{
Logger.LogVerbose("ProcessAsync begin: {0}", processor);
yield return(processor.OnAsyncProcess());
processor.ThreadHandle = 0;
Logger.LogVerbose("ProcessAsync end: {0}", processor);
}
public EventSetProcessor(
IAsyncProcessor <EventDetails, EventSetStorageProcessor.Result> storageProcessor,
IEventSetNotificationService notificationService)
{
this.storageProcessor = storageProcessor;
this.notificationService = notificationService;
output = this.storageProcessor.SelectMany(SendNotifications);
}
public MockPluginEnvironment(IResourceStore storage)
{
_picoContainer = new DefaultPicoContainer();
_mockPicoContainer = new DefaultPicoContainer(_picoContainer);
Storage = storage;
if (storage != null)
{
_picoContainer.RegisterComponentInstance(storage);
}
File.Delete(".\\MockPluginEnvironment.ini");
_settingStore = new Ini.IniFile(".\\MockPluginEnvironment.ini");
DynamicMock actionManagerMock = new DynamicMock(typeof(IActionManager));
actionManagerMock.SetupResult("GetKeyboardShortcut", "", typeof(IAction));
_actionManager = (IActionManager)actionManagerMock.MockInstance;
_uiManager = (IUIManager) new DynamicMock(typeof(IUIManager)).MockInstance;
_pluginLoader = (IPluginLoader) new DynamicMock(typeof(IPluginLoader)).MockInstance;
_resourceBrowser = (IResourceBrowser) new DynamicMock(typeof(IResourceBrowser)).MockInstance;
_tabManager = new MockTabManager();
_resourceAP = new MockAsyncProcessor();
_networkAP = new MockAsyncProcessor();
_uiAP = new MockAsyncProcessor();
DynamicMock resourceIconManagerMock = new DynamicMock(typeof(IResourceIconManager));
resourceIconManagerMock.SetupResult("IconColorDepth", ColorDepth.Depth8Bit);
resourceIconManagerMock.SetupResult("GetIconIndex", 0, typeof(IResource));
_resourceIconManager = (IResourceIconManager)resourceIconManagerMock.MockInstance;
_notificationManager = (INotificationManager) new DynamicMock(typeof(INotificationManager)).MockInstance;
_textIndexManager = (ITextIndexManager) new DynamicMock(typeof(ITextIndexManager)).MockInstance;
_messageFormatter = (IMessageFormatter) new DynamicMock(typeof(IMessageFormatter)).MockInstance;
_displayColumnManager = (IDisplayColumnManager) new DynamicMock(typeof(IDisplayColumnManager)).MockInstance;
// DynamicMock filterManagerMock = new DynamicMock( typeof(IFilterRegistry) );
DynamicMock filterEngineMock = new DynamicMock(typeof(IFilterEngine));
filterEngineMock.SetupResult("ExecRules", true, typeof(string), typeof(IResource));
DynamicMock filterManagerMock = new DynamicMock(typeof(IFilterRegistry));
_filterRegistry = (IFilterRegistry)filterManagerMock.MockInstance;
_rcManager = (IRemoteControlManager) new DynamicMock(typeof(IRemoteControlManager)).MockInstance;
_trayIconManager = (ITrayIconManager) new DynamicMock(typeof(ITrayIconManager)).MockInstance;
_formattingRuleManager = (IFormattingRuleManager) new DynamicMock(typeof(IFormattingRuleManager)).MockInstance;
_expirationRuleManager = (IExpirationRuleManager) new DynamicMock(typeof(IExpirationRuleManager)).MockInstance;
_filteringFormsManager = (IFilteringFormsManager) new DynamicMock(typeof(IFilteringFormsManager)).MockInstance;
_searchQueryExtensions = (ISearchQueryExtensions) new DynamicMock(typeof(ISearchQueryExtensions)).MockInstance;
_filterEngine = (IFilterEngine) new DynamicMock(typeof(IFilterEngine)).MockInstance;
theInstance = this;
}
public static void Uninstall(CoroutinePool pool, IAsyncProcessor processor)
{
if (null == pool)
{
throw new ArgumentNullException("pool");
}
if (processor.ThreadHandle > 0)
{
pool.StopCoroutine(processor.ThreadHandle);
}
processor.ThreadHandle = 0;
processor.IsSetup = false;
}
public AsyncComponent(IAsyncProcessor <TIn, TOut> processor,
ISubscriberPort <TIn> input,
IPublisherPort <TOut> output,
IPublisherPort <Exception> error)
{
_processor = processor;
_output = output;
_error = error;
processor.Exception += error.Publish;
processor.Output += output.Publish;
processor.Initialize(Fiber);
input.Subscribe(Fiber, processor.Process);
}
public static void Setup(CoroutinePool pool, IAsyncProcessor processor)
{
if (null == pool)
{
throw new ArgumentNullException("pool");
}
if (processor.IsSetup)
{
throw new AsyncRequestAlreadySetupException("Async processor cannot setup twice!");
}
processor.IsSetup = true;
processor.ThreadHandle = pool.StartCoroutine(ProcessAsync(processor));
Logger.LogVerbose("Coroutine setup, processor: {0}, handle: {1}", processor, processor.ThreadHandle);
}
internal static async Task ExecuteAsyncWithProgress(this IAsyncProcessor processor, bool throwOnError, object state)
{
if (ExecuteAsyncWithProgressAction != null)
{
await ExecuteAsyncWithProgressAction(processor, throwOnError, state).ConfigureAwait(false);
}
else
{
await processor.ExecuteAsync(null).ConfigureAwait(false);
}
if (processor.Exception != null && throwOnError)
{
throw processor.Exception;
}
}
internal static Task ExecuteAsyncWithProgress(this IAsyncProcessor processor, bool throwOnError, object state)
{
using (IProgressDialogAsyncView dialog = new ProgressDialogAsync())
{
dialog.AsyncProcessor = processor;
dialog.Icon = Properties.Resources.hfm_48_48;
dialog.Text = Core.Application.NameAndVersion;
var owner = GetOwnerFromState(state);
if (owner == null)
{
dialog.StartPosition = FormStartPosition.CenterScreen;
}
dialog.ShowDialog(owner);
}
if (processor.Exception != null && throwOnError)
{
throw processor.Exception;
}
return(Task.FromResult <object>(null));
}
public TestCore(Type resourceStoreType)
{
theInstance = this;
_basePicoContainer = _picoContainer;
_mockPicoContainer = new DefaultPicoContainer(_basePicoContainer);
_picoContainer = _mockPicoContainer;
_basePicoContainer.RegisterComponentImplementation(resourceStoreType);
_basePicoContainer.RegisterComponentImplementation(typeof(MockResourceTabProvider));
_resourceAP = new MockAsyncProcessor();
_networkAP = new MockAsyncProcessor();
_uiAP = new MockAsyncProcessor();
_basePicoContainer.RegisterComponentInstance(new DynamicMock(typeof(IPluginLoader)).MockInstance);
_basePicoContainer.RegisterComponentInstance(new DynamicMock(typeof(ITextIndexManager)).MockInstance);
_basePicoContainer.RegisterComponentInstance(new DynamicMock(typeof(IUIManager)).MockInstance);
_basePicoContainer.RegisterComponentInstance(new DynamicMock(typeof(IResourceBrowser)).MockInstance);
_basePicoContainer.RegisterComponentInstance(new DynamicMock(typeof(ISidebarSwitcher)).MockInstance);
DynamicMock resourceIconManagerMock = new DynamicMock(typeof(IResourceIconManager));
resourceIconManagerMock.SetupResult("IconColorDepth", ColorDepth.Depth8Bit);
resourceIconManagerMock.SetupResult("GetIconIndex", 0, typeof(IResource));
_basePicoContainer.RegisterComponentInstance(resourceIconManagerMock.MockInstance);
DynamicMock actionManagerMock = new DynamicMock(typeof(IActionManager));
actionManagerMock.SetupResult("GetKeyboardShortcut", "", typeof(IAction));
_basePicoContainer.RegisterComponentInstance(actionManagerMock.MockInstance);
_basePicoContainer.RegisterComponentInstance(new MockTabManager());
DynamicMock displayColumnManagerMock = new DynamicMock(typeof(IDisplayColumnManager));
_basePicoContainer.RegisterComponentInstance(displayColumnManagerMock.MockInstance);
File.Delete(".\\MockPluginEnvironment.ini");
_basePicoContainer.RegisterComponentInstance(new Ini.IniFile(".\\MockPluginEnvironment.ini"));
}
private void getArticleUnit_Finished(AsciiProtocolUnit unit)
{
if (_articleAvailable)
{
IAsyncProcessor ap = Core.ResourceAP;
if (_group == null)
{
ap.RunUniqueJob("Creating news article",
new CreateArticleByProtocolHandlerDelegate(NewsArticleParser.CreateArticleByProtocolHandler),
_lines.ToArray(typeof(string)), _article);
}
else
{
ap.QueueJob(_priority, "Creating news article",
new CreateArticleDelegate(NewsArticleParser.CreateArticle),
_lines.ToArray(typeof(string)), _group, _articleId);
}
}
_getArticleUnit = null;
FireFinished();
}
public static IAsyncProcessorBuilder UseMiddlewareAsync(this IAsyncProcessorBuilder asyncProcessorBuilder, IAsyncProcessor asyncProcessor, StageConfiguration stageConfiguration)
{
if ((object)asyncProcessorBuilder == null)
{
throw new ArgumentNullException(nameof(asyncProcessorBuilder));
}
if ((object)asyncProcessor == null)
{
throw new ArgumentNullException(nameof(asyncProcessor));
}
if ((object)stageConfiguration == null)
{
throw new ArgumentNullException(nameof(stageConfiguration));
}
return(asyncProcessorBuilder.UseAsync(asyncNext =>
{
return async(asyncContext, configuration, asyncChannel, cancellationToken) =>
{
IAsyncProcessor _asyncProcessor = asyncProcessor; // prevent closure bug
IAsyncChannel newAsyncChannel;
using (AsyncDisposal.Await(_asyncProcessor, cancellationToken))
{
_asyncProcessor.Configuration = stageConfiguration;
await _asyncProcessor.CreateAsync(cancellationToken);
await _asyncProcessor.PreExecuteAsync(asyncContext, configuration, cancellationToken);
newAsyncChannel = await _asyncProcessor.ProcessAsync(asyncContext, configuration, asyncChannel, asyncNext, cancellationToken);
await _asyncProcessor.PostExecuteAsync(asyncContext, configuration, cancellationToken);
return newAsyncChannel;
}
};
}));
}
public static void UpdateHttpStatus(IStatusWriter writer, string name, int bytes)
{
IAsyncProcessor ap = Core.UserInterfaceAP;
if (!ap.IsOwnerThread)
{
// update status in UI thread, because size formatting requires that
ap.QueueJob(JobPriority.Immediate,
new UpdateHttpStatusDelegate(UpdateHttpStatus), writer, name, bytes);
}
else
{
bytes &= ~1023;
StringBuilder builder = StringBuilderPool.Alloc();
try
{
builder.Append("Downloading ");
builder.Append(name);
if (bytes == 0)
{
builder.Append("...");
}
else
{
builder.Append(" (");
builder.Append(SizeToString(bytes));
builder.Append(')');
}
writer.ShowStatus(builder.ToString());
}
finally
{
StringBuilderPool.Dispose(builder);
}
}
}
public ParallelProcessor(IAsyncProcessor asyncProcessor)
{
this.asyncProcessor = asyncProcessor;
this.asyncProcessor.ProcessingEnded += AsyncProcessor_ProcessingEnded;
}
internal static async Task ExecuteAsyncWithProgress(this IAsyncProcessor processor, bool throwOnError)
{
await processor.ExecuteAsyncWithProgress(throwOnError, null).ConfigureAwait(false);
}
public void SetResourceAP(IAsyncProcessor asyncProcessor)
{
_resourceAP = asyncProcessor;
}
public void SetNetworkAP(IAsyncProcessor asyncProcessor)
{
_networkAP = asyncProcessor;
}
public GameClientApi(IAsyncProcessor asyncProcessor, IJsonSerializer json)
{
_asyncProcessor = asyncProcessor;
_json = json;
}
public static IList <TOutput> InvokeSync <TInput, TOutput>(this IAsyncProcessor <TInput, TOutput> processor, IList <TInput> input)
{
return(InvokeAsync(processor, input).Result);
}
/**
* IResource article can be null, in that case the new article is created
*/
public static IResource PlaceArticle(IResource article, IResource folder, IResourceList groups,
string from, string subject, string text, string charset, string references,
string nntpText, IResourceList attachments)
{
IResourceStore store = Core.ResourceStore;
if (!store.IsOwnerThread())
{
IAsyncProcessor resourceProcessor = Core.ResourceAP;
article = (IResource)resourceProcessor.RunUniqueJob(
new PlaceArticleDelegate(PlaceArticle), article, folder, groups, from,
subject, text, charset, references, nntpText, attachments);
}
else
{
if (article == null || article.IsDeleted)
{
article = store.BeginNewResource(NntpPlugin._newsLocalArticle);
}
else
{
article.BeginUpdate();
article.DeleteProp(NntpPlugin._propArticleId);
}
try
{
article.SetProp(Core.Props.Subject, subject);
article.SetProp(Core.Props.Date, DateTime.Now);
IContact sender;
NewsArticleParser.ParseFrom(article, from, out sender);
NewsArticleParser.ParseReferences(article, references);
article.SetProp(Core.Props.LongBody, text);
article.SetProp(Core.FileResourceManager.PropCharset, charset);
article.SetProp(NntpPlugin._propNntpText, nntpText);
if (!folder.IsDeleted)
{
article.SetProp(NntpPlugin._propTo, folder);
}
if (groups != null)
{
foreach (IResource group in groups)
{
if (!group.IsDeleted)
{
article.AddLink(NntpPlugin._propTo, group);
}
}
}
if (attachments != null)
{
foreach (IResource attachment in attachments)
{
if (!attachment.IsDeleted)
{
attachment.AddLink(NntpPlugin._propAttachment, article);
string actualResourceType =
Core.FileResourceManager.GetResourceTypeByExtension(
IOTools.GetExtension(attachment.GetPropText(Core.Props.Name)));
if (actualResourceType != null && attachment.Type != actualResourceType)
{
attachment.ChangeType(actualResourceType);
}
if (attachment.IsTransient)
{
attachment.EndUpdate();
}
}
}
}
Core.WorkspaceManager.AddToActiveWorkspace(article);
}
finally
{
article.EndUpdate();
Core.TextIndexManager.QueryIndexing(article.Id);
}
}
return(article);
}
/// <summary>
/// Initializes a new instance of the <see cref="AsyncProcessorDecoratorBase{TContext}"/> class.
/// </summary>
/// <param name="processor">The child processor.</param>
protected AsyncProcessorDecoratorBase(IAsyncProcessor <TContext> processor)
{
this.processor = processor ?? throw new ArgumentNullException(nameof(processor));
}
public EventSetProcessorTest()
{
var storageProcessor = AsyncProcessor.Create(storageProcessorDataflowMock.Object);
processor = new EventSetProcessor(storageProcessor, notificationServiceMock.Object);
}
internal static Task ExecuteAsyncWithProgress(this IAsyncProcessor processor, bool throwOnError)
{
return(processor.ExecuteAsyncWithProgress(throwOnError, null));
}
