public void TaskQueueMaxSizeTest()
{
var depth = 10;
var taskQueue = new TaskQueue();
taskQueue.SetMaxQueueSize(depth);
var wait = true;
for (var i = 0; i < depth; i++)
{
taskQueue.Enqueue(t => Task.Run(() =>
{
while (wait)
Thread.Sleep(5);
}), wait);
}
taskQueue.Size.Should().Be(depth);
var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait);
newItem.Should().BeNull("This should exceed the max and return a null task since it was not enqueued");
taskQueue.Size.Should().Be(depth);
wait = false;
Thread.Sleep(25);
newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait);
newItem.Should().NotBeNull("Released the queue and it should have space again");
}
public SqlColumn(string name, TaskQueue.FieldType vt, bool unique = false)
{
switch (vt)
{
case TaskQueue.FieldType.text:
DataType = SqlColumnDataType.nvarchar;
break;
case TaskQueue.FieldType.num_int:
DataType = SqlColumnDataType.n_integer;
break;
case TaskQueue.FieldType.num_double:
DataType = SqlColumnDataType.n_decimal;
break;
case TaskQueue.FieldType.boolean:
DataType = SqlColumnDataType.bit;
break;
case TaskQueue.FieldType.datetime:
DataType = SqlColumnDataType.datetime;
break;
default:
break;
}
Name = name;
UniqueId = unique;
}
public OwinWebSocket(IDictionary<string, object> owinEnvironment)
{
this.mSendAsync = (WebSocketSendAsync)owinEnvironment["websocket.SendAsync"];
this.mReceiveAsync = (WebSocketReceiveAsync)owinEnvironment["websocket.ReceiveAsync"];
this.mCloseAsync = (WebSocketCloseAsync)owinEnvironment["websocket.CloseAsync"];
this.mSendQueue = new TaskQueue();
}
public void ExceptionTest()
{
var queue = new TaskQueue();
AssertThrow<ArgumentNullException>(
() => queue.Enqueue(null),
() => queue.Enqueue((Func<Task<string>>)null));
}
public ZYEnsureSend(SocketAsyncEventArgs asyn,int maxSize)
{
Asyn = asyn;
BufferPool = new RingBuffer(maxSize);
TaskQueuePool = new TaskQueue<Socket>();
}
public MessageChannel(string uniqueName, string connectionParamsName, TaskQueue.TQItemSelector selector = null)
{
this.UniqueName = uniqueName;
this.ConnectionName = connectionParamsName;
if (selector == null)
this.consumerSelector = TaskQueue.TQItemSelector.DefaultFifoSelector;
else
this.consumerSelector = selector;
}
public void initThreadPool(int numThread, TaskQueue taskQueue)
{
m_list = new List<TaskThread>(numThread);
int idx = 0;
for(idx = 0; idx < numThread; ++idx)
{
m_list.Add(new TaskThread(string.Format("TaskThread{0}", idx), taskQueue));
m_list[idx].start();
}
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="taskQueue"></param>
/// <param name="luaSyntaxLanguage"></param>
/// <param name="broker"></param>
public Database(TaskQueue taskQueue, LuatSyntaxLanguage luaSyntaxLanguage, ILuaIntellisenseBroker broker)
{
Instance = this;
m_taskQueue = taskQueue;
m_language = luaSyntaxLanguage;
m_broker = broker;
Status = new StatusImpl();
}
public SqlTable(TaskQueue.RepresentedModel model, string tableName)
{
TableName = tableName;
Columns = new List<SqlColumn>();
Columns.Add(new SqlColumn(TableName + "_ID", TaskQueue.FieldType.num_int, true));
foreach (var clm in model.schema.ToList())
{
//Columns.Add(new SqlColumn(clm.Value1, clm.Value2));
}
}
public TaskBox(ITaskBoxStorage storage,
ITaskLogProvider logProvider,
int threadNum)
{
this.Storage = storage;
this.Log = logProvider;
this._threadNum = threadNum;
this._taskManager = new TaskQueue(this);
//��¼��־
//this.TaskStateChanged += this.Log.LogTaskState;
}
public void SetInstance(TaskQueue.ITQueue instance, QueueSpecificParameters parameters)
{
this.QueueTypeName = instance.QueueType;
this.QueueInstance = instance;
#if DEBUG
System.Diagnostics.Debug.Assert(instance.GetParametersModel().GetType() == parameters.GetType());
#endif
this.specParams = parameters;
string chkresult;
if (!parameters.Validate(out chkresult))
throw new Exception("Invalid parameters passed to queue: " + Name);
}
private LuaIntellisenseBroker()
{
TaskQueue = new TaskQueue();
TaskQueue.Start();
Application.ApplicationExit += (s, e) => TaskQueue.Stop();
CustomLuaSyntaxLanguage = new LuatSyntaxLanguage(this);
Database = new Database(TaskQueue, CustomLuaSyntaxLanguage, this);
m_fauxControl = new FauxSyntaxEditorColorer(CustomLuaSyntaxLanguage);
SkinService.SkinChangedOrApplied += SkinServiceSkinChangedOrApplied;
}
public static TaskQueue StartNew(string name, string displayName, TaskQueueOptions options, IQueueStore queueStore)
{
var queue = new TaskQueue(name, displayName, options, queueStore);
if (!_queues.TryAdd(name, queue))
{
queue.Dispose();
throw new InvalidOperationException("Not able to add the queue to the pool.");
}
else
{
queue.Start();
}
return queue;
}
public static IMongoQuery GetQuery(TaskQueue.TQItemSelector selector)
{
List<IMongoQuery> qs = new List<IMongoQuery>();
foreach (KeyValuePair<string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
{
switch (kv.Value.ValueSet)
{
case TaskQueue.TQItemSelectorSet.Equals:
Type kvt = kv.Value.Value.GetType();
qs.Add(new QueryDocument(new Dictionary<string, object>() { { kv.Key, kv.Value.Value } }));
break;
}
}
IMongoQuery q = Query.And(qs);
return q;
}
public void MainTest()
{
AsyncPump.Run(
async () =>
{
var counter = 0;
var queue = new TaskQueue();
queue.Enqueue(
async () =>
{
await Task.Delay(250);
++counter;
}).Ignore();
Assert.AreEqual(2, await queue.Enqueue(() => Task.FromResult(++counter)));
Assert.AreEqual(2, counter);
});
}
public static SortByBuilder GetSort(TaskQueue.TQItemSelector selector)
{
SortByBuilder sb = new SortByBuilder();
foreach (KeyValuePair<string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
{
switch (kv.Value.ValueSet)
{
case TaskQueue.TQItemSelectorSet.Ascending:
sb = sb.Ascending(kv.Key);
break;
case TaskQueue.TQItemSelectorSet.Descending:
sb = sb.Descending(kv.Key);
break;
}
}
return sb;
}
static StatusProxy()
{
_statusQueue = new TaskQueue<long, TwitterStatus>(200, TimeSpan.FromSeconds(30),
async s => await StoreStatusesAsync(s));
_favoriteQueue = new ActivityQueue(50, TimeSpan.FromSeconds(30),
s => Task.Run(() => Database.FavoritesCrud.InsertAllAsync(s)),
s => Task.Run(() => Database.FavoritesCrud.DeleteAllAsync(s)));
_retweetQueue = new ActivityQueue(50, TimeSpan.FromSeconds(30),
s => Task.Run(() => Database.RetweetsCrud.InsertAllAsync(s)),
s => Task.Run(() => Database.RetweetsCrud.DeleteAllAsync(s)));
App.ApplicationFinalize += () =>
{
_statusQueue.Writeback();
_favoriteQueue.Writeback();
_retweetQueue.Writeback();
};
}
private void WinFormsClient_Load(object sender, EventArgs e)
{
SyncSupplierQueue = new TaskQueue<ProductItem, SimpleResult>(cts.Token);
InteceptQueue = new AppQueue<InterceptInfo>(cts.Token);
CloseTradeQueue = new AppQueue<long>(cts.Token);
WaitUpWaitDownlist = new AppQueue<ProductItem[]>(cts.Token);
InstallCert();
wbLoginMode.UserCancelLogin += () => { this.Close(); };
wbTaoChongZhiMode.AskLogin += () => { this.InvokeAction(this.ShowLoginWindow, wb); };
var files = Directory.EnumerateFiles(Application.StartupPath, "*.bin");
if (files.Any())
{
var selectAccountForm = new SelectAccountForm();
foreach (var fName in files)
{
var uName = Path.GetFileNameWithoutExtension(fName);
if (!string.IsNullOrEmpty(uName))
{
var button = new Button()
{
Size = new Size(140, 30),
Text = uName,
};
button.Click += OnSelectAccountButtonClick;
selectAccountForm.AccountButtons.Add(button);
}
}
if (selectAccountForm.AccountButtons.Count > 1)
selectAccountForm.ShowDialog();
}
wbLoginMode.Enter(wb);
var x = new TaoLoginForm(wbLoginMode).ShowDialog();
if (x != DialogResult.OK)
{
Environment.Exit(0);
}
LoadMenuItemSetting();
this.dataGridViewItem.ContextMenuStrip = contextMenuStrip1;
this.OnLoginSuccess();
tabPage2.Controls.Add(wb);
WBHelper.InitWBHelper(wbArrayWrapper, "http://chongzhi.taobao.com/index.do?method=index");
}
public void TaskQueueSizeTest()
{
var depth = 10;
var taskQueue = new TaskQueue();
var wait = true;
for (var i = 0; i < depth; i++)
{
taskQueue.Enqueue(t => Task.Run(() =>
{
while(wait)
Thread.Sleep(5);
}), wait);
}
taskQueue.Size.Should().Be(depth);
wait = false;
Thread.Sleep(25);
taskQueue.Size.Should().Be(0);
}
public static IndexKeysBuilder GetIndex(TaskQueue.TQItemSelector selector)
{
IndexKeysBuilder ikb = new IndexKeysBuilder();
foreach (KeyValuePair<string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
{
switch (kv.Value.ValueSet)
{
case TaskQueue.TQItemSelectorSet.Equals:
Type kvt = kv.Value.Value.GetType();
if (kvt == typeof(bool))
{
if ((bool)kv.Value.Value)
{
ikb = ikb.Ascending(kv.Key);
}
else
{
ikb = ikb.Descending(kv.Key);
}
}
else
{
ikb = ikb.Ascending(kv.Key);
}
break;
}
}
foreach (KeyValuePair<string, TaskQueue.TQItemSelectorParam> kv in selector.parameters)
{
switch (kv.Value.ValueSet)
{
case TaskQueue.TQItemSelectorSet.Ascending:
ikb = ikb.Ascending(kv.Key);
break;
case TaskQueue.TQItemSelectorSet.Descending:
ikb = ikb.Descending(kv.Key);
break;
}
}
return ikb;
}
public void TaskQueueDrainTest()
{
var depth = 10;
var taskQueue = new TaskQueue();
taskQueue.SetMaxQueueSize(depth);
var wait = true;
for (var i = 0; i < depth; i++)
{
taskQueue.Enqueue(t => Task.Run(() =>
{
while (wait)
Thread.Sleep(10);
}), wait);
}
wait = false;
taskQueue.Drain();
taskQueue.Size.Should().Be(0);
var newItem = taskQueue.Enqueue(t => Task.FromResult(0), wait);
newItem.Should().NotBeNull();
}
public Cloud()
{
registerViewModel = new Register();
accountViewModel = new Account();
libraryViewModel = new Library(accountViewModel);
queueViewModel = new Queue();
queueViewModel.Cloud = this;
notificationsViewModel = new Notifications(this);
productsViewModel = new Products(this, accountViewModel, queueViewModel);
mediaContentViewModel = new MediaContent(queueViewModel, accountViewModel, productsViewModel);
accountViewModel.MediaContent = mediaContentViewModel;
accountViewModel.Register = registerViewModel;
queueViewModel.Account = accountViewModel;
queueViewModel.MediaContent = mediaContentViewModel;
SelectItem = new Command <CloudItem>((parameter) =>
{
SelectedItem = parameter;
});
#if _IOS_
RemoteNotificationsService.Instance.NotificationReceived += handleNotificationReceived;
#endif
GoHome = new Command(() =>
{
SelectedItem = CloudItem.Content;
mediaContentViewModel.GoHome();
});
OpenUrl = new Command <string>((parameter) => Device.OpenUri(new Uri(parameter)));
AppNavigation.AppNavigate += AppNavigation_AppNavigate;
NavigateToRecording = new Command <Notification>((parameter) =>
{
TaskQueue.Enqueue(() => navigateToRecordingFromNotification(parameter));
if ((Application.Current.MainPage as NavigationPage).CurrentPage is DetailsPage)
{
Application.Current.MainPage.Navigation.PopAsync();
}
});
ReachabilityHelperService.NetworkStatusChanged += async(sender, e) =>
{
await NetworkStatusChanged(e);
};
RestService.Instance.ServerConnectionLost += (sender, e) =>
{
if (IsInBackground)
{
return;
}
Device.BeginInvokeOnMainThread(async() =>
{
if (!e.Silent)
{
try
{
if (await Application.Current.MainPage.DisplayAlert("Can't connect",
"We were unable to reach the server. Please check your internet connection and make sure you are online before hitting Refresh",
"Go Offline",
"Refresh"))
{
await NetworkStatusChanged(NetworkStatus.NotReachable);
e.Cancel.SetResult(true);
}
else
{
e.Cancel.SetResult(true);
}
}
catch (Exception ex)
{
e.Cancel.SetException(ex);
}
}
else
{
await NetworkStatusChanged(NetworkStatus.NotReachable);
e.Cancel.SetResult(true);
}
});
};
RestService.Instance.ServerConnectionRestored += async(sender, e) =>
{
await NetworkStatusChanged(NetworkStatus.ReachableViaWiFiNetwork);
};
mediaContentViewModel.OnSelectedItemDetailsChanged += MediaContentViewModel_OnSelectedItemDetailsChanged;
libraryViewModel.OnSelectedItemDetailsChanged += LibraryViewModel_OnSelectedItemDetailsChanged;
queueViewModel.OnSelectedItemDetailsChanged += QueueViewModel_OnSelectedItemDetailsChanged;
notificationsViewModel.OnSelectedItemDetailsChanged += NotificationsViewModel_OnSelectedItemDetailsChanged;
BackButtonHelper.BackButtonPressed += async(sender, args) =>
{
switch (SelectedItem)
{
case CloudItem.Account:
break;
case CloudItem.Content:
await mediaContentViewModel.OnBackButtonPressed();
break;
case CloudItem.Library:
break;
case CloudItem.Notifications:
break;
case CloudItem.Queue:
break;
}
;
//Calling this is kind of hacky but it does not hurt
await registerViewModel.OnBackButtonPressed();
};
}
protected Server()
{
apiTaskQuee = new TaskQueue <HttpListenerContext>(this.ProcessQuee, OnProcessQueeError);
paquetQueue = new TaskQueue <IAsyncResult>(this.PacketProcess, OnProcessPacketError);
CommandsQueue = new TaskQueue <CommandsParam>(this.CommandProcesser, this.OnCommandProcesserError);
}
private static void Process(Task task)
{
TaskQueue.Process(Context, task);
}
public void Setup(TaskQueue self)
{
this.self = self;
}
/// <summary>
/// Initializes a new instance of the <see cref="T:System.Object"/> class.
/// </summary>
public TeamRoomHelper(Uri teamProjectCollectionUri)
{
cancellationTokenSource = new CancellationTokenSource();
this.teamProjectCollectionUri = teamProjectCollectionUri;
queue = new TaskQueue(cancellationTokenSource);
}
public static void AutoCycle(
Interactor intr,
int startDelaySec)
{
if (intr.CancelSource.IsCancellationRequested) { return; }
var queue = new TaskQueue();
int charsTotal = intr.AccountSettings.GetSettingValOr("characterCount", "general", 0);
if (queue.IsEmpty) {
intr.Log("Populating task queue: (0 -> " + (charsTotal).ToString() + ")");
queue.Populate(intr, charsTotal, RESET_DAY);
intr.UpdateQueueList(queue.ListClone(intr));
}
intr.Log("Starting AutoCycle in " + startDelaySec.ToString() + " seconds...");
intr.Wait(startDelaySec * 1000);
if (intr.CancelSource.IsCancellationRequested) { return; }
intr.Log("Beginning AutoCycle.");
// ##### BEGIN AUTOCYCLE LOOP #####
while (!queue.IsEmpty && !intr.CancelSource.IsCancellationRequested) {
if (IsCurfew()) {
int sleepTime = intr.WaitRand(300000, 1800000);
intr.Log("Curfew time. Sleeping for " + (sleepTime / 60000).ToString() + " minutes.");
}
intr.Log(LogEntryType.Debug, "AutoCycle(): Loop iteration starting.");
TimeSpan nextTaskMatureDelay = queue.NextTaskMatureDelay();
intr.Log(LogEntryType.Debug, "AutoCycle(): Next task mature delay: " + nextTaskMatureDelay);
if (nextTaskMatureDelay.Ticks <= 0) {
// TASK TIMER HAS MATURED -> CONTINUE
// ##### ENTRY POINT -- INVOKING & PROCESSING CHARACTER #####
ProcessCharacter(intr, queue);
} else {
// TASK TIMER NOT MATURE YET -> WAIT
intr.Wait(1000);
intr.Log("Next task matures in " + nextTaskMatureDelay.TotalMinutes.ToString("F0") + " minutes.");
TimeSpan waitDelay = nextTaskMatureDelay;
if (nextTaskMatureDelay.TotalMinutes > 8) {
if (queue.NextTask.Kind == TaskKind.Profession) {
waitDelay = nextTaskMatureDelay + intr.RandomDelay(9, 25);
} else {
waitDelay = nextTaskMatureDelay + intr.RandomDelay(9, 15);
}
ProduceClientState(intr, ClientState.None, 0);
} else if (nextTaskMatureDelay.TotalSeconds > 1) {
// Delay more than 1 sec, let the train catch up...
ProduceClientState(intr, ClientState.Inactive, 0);
waitDelay = nextTaskMatureDelay + intr.RandomDelay(5, 11);
intr.Log("Minimizing client and waiting " + waitDelay.TotalMinutes.ToString("F0") + " minutes.");
}
if (waitDelay.TotalSeconds > 1) {
intr.Log("Sleeping for " + waitDelay.TotalMinutes.ToString("F0") + " minutes before continuing...");
intr.Wait(waitDelay);
Screen.Wake(intr);
}
}
intr.Wait(100);
}
intr.Log(LogEntryType.Info, "Autocycle complete.");
}
IEnumerator IEnumerable.GetEnumerator()
{
return(TaskQueue.GetEnumerator());
}
public IEnumerator <IUpdaterTask> GetEnumerator()
{
return(TaskQueue.GetEnumerator());
}
/// <summary>
/// Creates a new connection.
/// </summary>
/// <param name="socket">Web-socket.</param>
/// <param name="cookies">Cookie key-value pairs.</param>
internal protected WebSocketWrapper(WebSocket socket, IReadOnlyDictionary <string, string> cookies)
{
this.socket = socket;
this.sendTaskQueue = new TaskQueue();
this.Cookies = cookies;
}
public void RequestCompletesAfterFaultedInitializeResponse()
{
// Arrange
var response = new Mock <IResponse>();
response.Setup(m => m.CancellationToken).Returns(CancellationToken.None);
var request = new Mock <IRequest>();
var qs = new NameValueCollection();
qs["connectionId"] = "1";
request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs));
request.Setup(m => m.LocalPath).Returns("/test/echo/connect");
var counters = new PerformanceCounterManager();
var heartBeat = new Mock <ITransportHeartbeat>();
var json = new JsonSerializer();
var hostContext = new HostContext(request.Object, response.Object);
var transportConnection = new Mock <ITransportConnection>();
var traceManager = new Mock <ITraceManager>();
traceManager.Setup(m => m[It.IsAny <string>()]).Returns(new System.Diagnostics.TraceSource("foo"));
transportConnection.Setup(m => m.Receive(It.IsAny <string>(),
It.IsAny <Func <PersistentResponse, object, Task <bool> > >(),
It.IsAny <int>(),
It.IsAny <object>()))
.Returns <string, Func <PersistentResponse, object, Task <bool> >, int, object>(
(messageId, callback, maxMessages, state) =>
new DisposableAction(() => callback(new PersistentResponse(), state))
);
var transport = new Mock <ForeverTransport>(hostContext, json, heartBeat.Object, counters, traceManager.Object)
{
CallBase = true
};
var queue = new TaskQueue();
transport.Setup(t => t.EnqueueOperation(It.IsAny <Func <object, Task> >(), It.IsAny <object>()))
.Returns <Func <object, Task>, object>(
(writeAsync, state) => queue.Enqueue(writeAsync, state));
transport.Setup(t => t.InitializeResponse(It.IsAny <ITransportConnection>()))
.Returns <ITransportConnection>(
pr => TaskAsyncHelper.FromError(new Exception()));
transport.Setup(t => t.Send(It.IsAny <PersistentResponse>()))
.Returns <PersistentResponse>(
pr => transport.Object.EnqueueOperation(() => TaskAsyncHelper.Empty));
var tcs = new TaskCompletionSource <bool>();
transport.Object.AfterRequestEnd = (ex) =>
{
// Trip the cancellation token
tcs.TrySetResult(transport.Object.WriteQueue.IsDrained);
};
// Act
transport.Object.ProcessRequest(transportConnection.Object);
// Assert
Assert.True(tcs.Task.Wait(TimeSpan.FromSeconds(2)));
Assert.True(tcs.Task.Result);
}
public void InitializeResponseIsFirstEnqueuedOperation()
{
// Arrange
var response = new Mock <IResponse>();
response.Setup(m => m.CancellationToken).Returns(CancellationToken.None);
var request = new Mock <IRequest>();
var qs = new NameValueCollection();
qs["connectionId"] = "1";
request.Setup(m => m.QueryString).Returns(new NameValueCollectionWrapper(qs));
request.Setup(m => m.LocalPath).Returns("/test/echo/connect");
var counters = new Mock <IPerformanceCounterManager>();
var heartBeat = new Mock <ITransportHeartbeat>();
var json = new JsonSerializer();
var hostContext = new HostContext(request.Object, response.Object);
var transportConnection = new Mock <ITransportConnection>();
var traceManager = new Mock <ITraceManager>();
counters.SetupGet(m => m.ConnectionsConnected).Returns(new NoOpPerformanceCounter());
counters.SetupGet(m => m.ErrorsTransportTotal).Returns(new NoOpPerformanceCounter());
counters.SetupGet(m => m.ErrorsTransportPerSec).Returns(new NoOpPerformanceCounter());
counters.SetupGet(m => m.ErrorsAllTotal).Returns(new NoOpPerformanceCounter());
counters.SetupGet(m => m.ErrorsAllPerSec).Returns(new NoOpPerformanceCounter());
traceManager.Setup(m => m[It.IsAny <string>()]).Returns(new System.Diagnostics.TraceSource("foo"));
transportConnection.Setup(m => m.Receive(It.IsAny <string>(),
It.IsAny <Func <PersistentResponse, object, Task <bool> > >(),
It.IsAny <int>(),
It.IsAny <object>()))
.Returns <string, Func <PersistentResponse, object, Task <bool> >, int, object>(
(messageId, callback, maxMessages, state) =>
{
callback(new PersistentResponse(), state);
return(DisposableAction.Empty);
});
var transport = new Mock <ForeverTransport>(hostContext, json, heartBeat.Object, counters.Object, traceManager.Object)
{
CallBase = true
};
var queue = new TaskQueue();
var results = new List <string>();
transport.Setup(t => t.EnqueueOperation(It.IsAny <Func <object, Task> >(), It.IsAny <object>()))
.Returns <Func <object, Task>, object>(
(writeAsync, state) =>
{
return(queue.Enqueue(writeAsync, state));
});
transport.Setup(t => t.InitializeResponse(It.IsAny <ITransportConnection>()))
.Returns <ITransportConnection>(
pr =>
{
results.Add("InitializeResponse");
return(TaskAsyncHelper.Empty);
});
transport.Setup(t => t.Send(It.IsAny <PersistentResponse>()))
.Returns <PersistentResponse>(
pr =>
transport.Object.EnqueueOperation(() =>
{
results.Add("Send");
return(TaskAsyncHelper.Empty);
}));
// Act
transport.Object.ProcessRequest(transportConnection.Object);
// Assert
Assert.Equal("InitializeResponse", results[0]);
Assert.Equal("Send", results[1]);
}
static UserProxy()
{
_userQueue = new TaskQueue <long, TwitterUser>(50, TimeSpan.FromSeconds(30),
async u => await StoreUsersAsync(u));
App.ApplicationFinalize += () => _userQueue.Writeback();
}
public static void Remove(Task task)
{
TaskQueue.Remove(task);
}
public static void ConnectEngineToGUI()
{
if (IsLocalEngine)
{
// HACK: SessionManager.Register() is not used for local engines
_LocalSession.RegisterFrontendUI(_MainWindow.UI);
}
SyncConfig();
_FrontendManager = _Session.GetFrontendManager(_MainWindow.UI);
_FrontendManager.Sync();
// MS .NET doesn't like this with Remoting?
if (Type.GetType("Mono.Runtime") != null)
{
// when are running on Mono, all should be good
if (_UserConfig.IsCaching)
{
// when our UserConfig is cached, we need to invalidate the cache
// DISABLED: see FrontendManager._OnConfigChanged
//_FrontendManager.ConfigChangedDelegate = SyncConfig;
}
}
_MainWindow.ShowAll();
// make sure entry got attention :-P
_MainWindow.Entry.HasFocus = true;
// local sessions can't have network issues :)
if (_Session != _LocalSession)
{
_FrontendManagerCheckerQueue = new TaskQueue("FrontendManagerCheckerQueue");
_FrontendManagerCheckerQueue.AbortedEvent += delegate {
#if LOG4NET
_Logger.Debug("_FrontendManagerCheckerQueue.AbortedEvent(): task queue aborted!");
#endif
};
_FrontendManagerCheckerQueue.ExceptionEvent +=
delegate(object sender, TaskQueueExceptionEventArgs e) {
#if LOG4NET
_Logger.Error("Exception in TaskQueue: ", e.Exception);
_Logger.Error("Inner-Exception: ", e.Exception.InnerException);
#endif
Frontend.ShowException(e.Exception);
};
_FrontendManagerCheckerQueue.Queue(delegate {
// keep looping as long as the checker returns true
while (CheckFrontendManagerStatus())
{
// FIXME: bail out somehow when we lost the connection
// without an exception in the meantime
// only check once per minute
Thread.Sleep(60 * 1000);
}
#if LOG4NET
_Logger.Debug("_FrontendManagerCheckerQueue(): " +
"CheckFrontendManagerStatus() returned false, " +
"time to say good bye!");
#endif
});
}
MainWindow.ChatViewManager.IsSensitive = true;
}
public static void StartOrResumeTasks(bool appWasRestarted)
{
if (WebConfigSettings.DisableTaskQueue)
{
return;
}
List <TaskQueue> unfinishedTasks;
SiteSettings siteSettings = null;
try
{
TaskQueue.DeleteCompleted();
// the default is false and it may be problematic to try and use this as true
// because the app start event only fires 1 time not 1 time per site
if (WebConfigSettings.UsePerSiteTaskQueue)
{
// this also doesn't work in IIS 7 integrated pipeline mode because HttpContext is null
siteSettings = CacheHelper.GetCurrentSiteSettings();
}
if ((WebConfigSettings.UsePerSiteTaskQueue) && (siteSettings != null))
{
unfinishedTasks = TaskQueue.GetUnfinished(siteSettings.SiteGuid);
}
else
{
unfinishedTasks = TaskQueue.GetUnfinished();
}
if (WebTaskManagerIsRunning(unfinishedTasks, appWasRestarted))
{
return;
}
if ((appWasRestarted) && (unfinishedTasks.Count == 0))
{
return;
}
WebTaskManager taskManager = new WebTaskManager();
taskManager.QueueTask();
taskManager.StartTask();
}
catch (DbException ex)
{
log.Error(ex);
}
catch (InvalidOperationException ex)
{
log.Error(ex);
}
catch (Exception ex)
{
// hate to trap System.Exception but SqlCeException doe snot inherit from DbException as it should
if (DatabaseHelper.DBPlatform() != "SqlCe")
{
throw;
}
log.Error(ex);
}
}
public void Flush()
{
BeginFlush(DateTime.Now);
TaskQueue.WaitForAllTasksCompleted();
}
public void ItExecutesTasksOnlyOnceWhenUsingMultipleConsumers(string taskType)
{
var semaphoreFile = Path.GetTempFileName();
File.Delete(semaphoreFile);
File.Create(semaphoreFile).Close();
var intervalSeconds = 5;
var taskSchedulers = new[]
{
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false),
new TaskScheduler(TaskQueue.Redis(TaskQueueTestFixture.RedisConnectionString), restoreFromBackup: false)
};
foreach (var taskScheduler in taskSchedulers)
{
if (taskType == "scheduled")
{
taskScheduler.AddScheduledTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), RandomTaskName);
}
if (taskType == "recurring")
{
taskScheduler.AddRecurringTask(() => TaskQueueTestFixture.WriteSempaphore(semaphoreFile),
TimeSpan.FromSeconds(intervalSeconds), RandomTaskName);
}
}
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
// Ran only once
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
File.Exists(semaphoreFile).Should().Be(true);
File.ReadAllText(semaphoreFile).Should().Be(TaskQueueTestFixture.SemaphoreText);
// Ran only twice (or once if scheduled)
Thread.Sleep(((intervalSeconds) * 1000) + 1000);
Task.WaitAll(
taskSchedulers.Select(
taskScheduler =>
Task.Run(() => taskScheduler.Tick())).ToArray(), 1000);
if (taskType == "recurring")
{
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText + TaskQueueTestFixture.SemaphoreText);
}
if (taskType == "scheduled")
{
File.ReadAllText(semaphoreFile).Should()
.Be(TaskQueueTestFixture.SemaphoreText);
}
taskSchedulers[0].FlushBackupStorage();
}
public static Task PeekNext()
{
return(TaskQueue.PeekNext());
}
/// <summary>
/// Check Apfell endpoint for new task
/// </summary>
/// <returns>CaramelTask with the next task to execute</returns>
override public Mythic.Structs.TaskQueue GetMessages(Apollo.Agent agent)
{
Stopwatch sw = new Stopwatch();
sw.Start();
//DebugWriteLine("Attempting to send SOCKS datagrams...");
//SendSocksDatagrams();
sw.Stop();
DebugWriteLine($"SendSocksDatagrams took {Utils.StringUtils.FormatTimespan(sw.Elapsed)} to run.");
sw.Restart();
//DebugWriteLine("Sent all SOCKS datagrams!");
TaskQueue response = new TaskQueue();
List <Task> finalTaskList = new List <Task>();
List <DelegateMessage> finalDelegateMessageList = new List <DelegateMessage>();
CheckTaskingRequest req = new CheckTaskingRequest()
{
action = "get_tasking",
tasking_size = -1
};
if (DelegateMessageRequestQueue.Count > 0)
{
DelegateMessageRequestMutex.WaitOne();
req.delegates = DelegateMessageRequestQueue.ToArray();
DelegateMessageRequestQueue.Clear();
DelegateMessageRequestMutex.ReleaseMutex();
}
else
{
req.delegates = new Dictionary <string, string>[] { };
}
// Could add delegate post messages
string json = JsonConvert.SerializeObject(req);
string id = Guid.NewGuid().ToString();
if (Send(id, json))
{
string returnMsg = (string)Inbox.GetMessage(id);
//JObject test = (JObject)JsonConvert.DeserializeObject(returnMsg);
////Dictionary<string, object>[] testDictTasks = test.Value<Dictionary<string, object>[]>("tasks");
//Task[] testTasks = test.Value<Task[]>("tasks");
Mythic.Structs.CheckTaskingResponse resp = JsonConvert.DeserializeObject <Mythic.Structs.CheckTaskingResponse>(returnMsg);
if (resp.tasks != null)
{
foreach (Task task in resp.tasks)
{
Debug.WriteLine("[-] CheckTasking - NEW TASK with ID: " + task.id);
finalTaskList.Add(task);
}
}
if (resp.delegates != null)
{
foreach (Dictionary <string, string> delmsg in resp.delegates)
{
string uuid = delmsg.Keys.First();
finalDelegateMessageList.Add(new DelegateMessage()
{
UUID = uuid,
Message = delmsg[uuid]
});
}
}
if (resp.socks != null)
{
response.SocksDatagrams = resp.socks;
}
}
response.Delegates = finalDelegateMessageList.ToArray();
response.Tasks = finalTaskList.ToArray();
sw.Stop();
DebugWriteLine($"Get tasking took {Utils.StringUtils.FormatTimespan(sw.Elapsed)} to run.");
//SCTask task = JsonConvert.DeserializeObject<SCTask>(Post(json));
return(response);
}
static TestTaskQueue()
{
Queue = new TaskQueue();
}
static UserProxy()
{
_userQueue = new TaskQueue<long, TwitterUser>(50, TimeSpan.FromSeconds(30),
async u => await StoreUsersAsync(u));
App.ApplicationFinalize += () => _userQueue.Writeback();
}
public EMail(TaskQueue.Providers.TaskMessage holder)
: base(holder.MType)
{
this.SetHolder(holder.GetHolder());
}
public ParseCurrentConfigController(IStorageController storageController)
{
StorageController = storageController;
OperationQueue = new TaskQueue {
};
}
public SmtpModel(TaskQueue.Providers.TItemModel holder)
{
this.SetHolder(holder.GetHolder());
}
/// <summary>
/// /// 执行队列
/// 执行TaskQueue中的队列
/// Executes the task.
/// </summary>
/// <typeparam name="TParameter"></typeparam>
/// <param name="moduleType"></param>
/// <param name="taskQueue"></param>
/// <param name="parameter"></param>
public void ExecuteQueue <TParameter>(Type moduleType, TaskQueue taskQueue, TParameter parameter)
where TParameter : class
{
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (moduleType == null)
{
throw new ArgumentNullException(nameof(moduleType));
}
var taskModuleAttribute = moduleType.GetTypeInfo().GetAttribute <TaskModuleAttribute>();
if (taskModuleAttribute == null)
{
throw new ArgumentNullException(nameof(moduleType));
}
// 如果模块Id不相同退出
if (taskModuleAttribute.Id != taskQueue.ModuleId)
{
return;
}
//从数据库中获取所有分润模块
var modules = _taskModuleFactory.CreateModules(moduleType);
if (modules.Count() <= 0)
{
return;
}
// 参数处理
var taskParameter = new TaskParameter();
var propertyList = GetOrCreatePropertyCache <TParameter>();
foreach (var item in propertyList)
{
taskParameter.AddValue(item.Key.Name, item.Value(parameter));
}
//var taskMessage = new TaskMessage
//{
// Type = moduleType.FullName,
// ModuleId = taskModuleAttribute.Id,
// ModuleName = taskModuleAttribute.Name
//};
IList <ITaskResult> resultList = new List <ITaskResult>();
var success = false;
foreach (var item in modules)
{
taskParameter.TryGetValue("QueueId", out long queueId);
try
{
var result = item.Execute(taskParameter);
if (result != null)
{
if (result.Status == ResultStatus.Success && result.Result.Count() > 0)
{
resultList.AddRange(result.Result);
success = true;
}
else
{
var taskQueueUpdate = Ioc.Resolve <ITaskQueueService>().GetSingle(taskQueue.Id);
// 将操作记录更新到数据
//taskMessage.Message = result.Message;
taskQueueUpdate.Status = QueueStatus.Error;
// taskQueueUpdate.Message = $"升级队列失败,.message{taskMessage.Message}";
taskQueueUpdate.HandleTime = DateTime.Now;
Ioc.Resolve <ITaskQueueService>().Update(taskQueueUpdate);
_logger.LogWarning(result.Message);
}
}
} catch (Exception ex)
{
//执行出错，将错误写入到数据库中
var taskQueueUpdate = Ioc.Resolve <ITaskQueueService>().GetSingle(taskQueue.Id);
// taskMessage.Message = $"升级队列失败执行出错{moduleType}:{ex.Message}";
taskQueueUpdate.Status = QueueStatus.Error;
// taskQueueUpdate.Message = $"{taskMessage.Message}";
taskQueueUpdate.HandleTime = DateTime.Now;
Ioc.Resolve <ITaskQueueService>().Update(taskQueueUpdate);
}
}
var repositoryContext = Ioc.Resolve <IUserRepository>().RepositoryContext;
IList <UserGradeChangeResult> gradeResultList = new List <UserGradeChangeResult>();
foreach (var graderesult in resultList)
{
if (graderesult is UserGradeChangeResult)
{
gradeResultList.Add((UserGradeChangeResult)graderesult);
}
}
// 更新分润结果，财务结果到数据库
Ioc.Resolve <IShareRepository>().UpdateUpgradeTaskResult(gradeResultList);
if (success)
{
//更新成功
var taskQueueUpdate = Ioc.Resolve <ITaskQueueService>().GetSingle(taskQueue.Id);
taskQueueUpdate.Status = QueueStatus.Handled;
taskQueueUpdate.Message = "success";
taskQueueUpdate.HandleTime = DateTime.Now;
taskQueueUpdate.ExecutionTimes = taskQueue.ExecutionTimes + 1;
Ioc.Resolve <ITaskQueueService>().Update(taskQueueUpdate);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="Parse.Core.Internal.ParseCurrentConfigController"/> class.
/// </summary>
public AVCurrentConfigController(IStorageController storageController)
{
this.storageController = storageController;
taskQueue = new TaskQueue();
}
public FileCopyService(TaskQueue taskQueue)
{
_taskQueue = taskQueue;
}
public NetWebSocket(WebSocket webSocket)
{
this.mWebSocket = webSocket;
this.mSendQueue = new TaskQueue();
}
/// <summary>
/// 资源已加载好，异步完成加载(即调回用户回调)
/// </summary>
/// <param name="onFinish"></param>
private static void AsyncFinishLoading(Action onFinish)
{
if (m_finishLoadingTaskQueue == null)
{
m_finishLoadingTaskQueue = new TaskQueue("AsyncFinishLoading");
m_finishLoadingTaskQueue.ActionCountLimit = 2;
}
m_finishLoadingTaskQueue.AddActionInMainThread(onFinish);
}
private static void ExecuteCommand(TaskQueue <CommandsParam> queue, CommandsParam param)
{
var x = (Server)param.Parms;
x.Api(param.Args);
}
///////////////
///
/// Here is the constructor
///
////////////////
/**
* @param local the local Node to connect to the remote node
* @param target the address of the node you are trying to connect
* to. Set to null if you don't know
* @param target_list an enumerable list of TransportAddress of the
* Host we want to connect to
* @param t ConnectionType string of the new connection
* @token unique token to associate the different connection setup messages
*/
public Linker(Node local, Address target, ICollection target_list, string ct, string token)
{
_task = new LinkerTask(local.Address, target, ct);
_local_n = local;
_active_lps_count = 0;
//this TaskQueue starts new tasks in the announce thread of the node.
_task_queue = new NodeTaskQueue(local);
_task_queue.EmptyEvent += this.FinishCheckHandler;
_ta_queue = new Brunet.Util.LockFreeQueue<TransportAddress>();
if( target_list != null ) {
int count = 0;
Hashtable tas_in_queue = new Hashtable( _MAX_REMOTETAS );
foreach(TransportAddress ta in target_list ) {
if(tas_in_queue.ContainsKey(ta) ) {
// Console.Error.WriteLine("TA: {0} appeared in list twice", ta);
}
else {
_ta_queue.Enqueue(ta);
tas_in_queue[ta] = null; //Remember that we've seen this one
if( target != null ) {
/*
* Make sure we don't go insane with TAs
* we know who we want to try to connect to,
* if it doesn't work after some number of
* attempts, give up. Don't go arbitrarily
* long
*/
count++;
if( count >= _MAX_REMOTETAS ) { break; }
}
}
}
}
_added_cons = 0; //We have not added a connection yet
_contype = ct;
_maintype = Connection.StringToMainType( _contype );
_target = target;
_token = token;
_ta_to_restart_state = new Hashtable( _MAX_REMOTETAS );
_started = 0;
_hold_fire = 1;
_cph_transfer_requests = 0;
#if LINK_DEBUG
_lid = Interlocked.Increment(ref _last_lid);
if(ProtocolLog.LinkDebug.Enabled) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format("{0}: Making {1}",
_local_n.Address, this));
if( target_list != null ) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format("TAs:"));
foreach(TransportAddress ta in target_list) {
ProtocolLog.Write(ProtocolLog.LinkDebug, String.Format("{0}", ta));
}
}
}
#endif
}
public HarvestingOrchestratorService(TaskQueue taskQueue, IOptions <HarvestingOrchestratorServiceOptions> harvestingOrchestratorServiceOptions)
{
this._taskQueue = taskQueue;
this._harvestingOrchestratorServiceOptions = harvestingOrchestratorServiceOptions.Value;
}
public static Task Enqueue(string taskType, string arguments)
{
int taskId = Queue.Enqueue(taskType, arguments);
return(TaskQueue.Read(taskId));
}
protected virtual void BeginFlush(DateTime date)
{
try
{
if (Disabled)
{
return;
}
if (Queue.Count() == 0)
{
return;
}
if (Client.CanSendData == false)
{
return;
}
if (Client.CanConvertToServerDate() == false)
{
return;
}
List <BufferEventData> allEvents = null;
lock (Queue.SynchRoot)
{
allEvents = Queue.GetAll();
}
if (allEvents == null || allEvents.Count == 0)
{
return;
}
// получаем события для отправки
int maxSendCount = Client.Config.Events.EventManager.MaxSend;
var sendEvents = allEvents
.Where(x =>
x.Status == AddEventStatus.WaitForSend &&
x.CreateDate <= date &&
x.ComponentControl.IsFake() == false)
.OrderBy(x => x.Errors)
.ThenBy(x => x.CreateDate)
.Take(maxSendCount)
.ToList();
// получаем события для склейки
int maxJoinCount = Client.Config.Events.EventManager.MaxJoin;
var joinEvents = allEvents
.Where(x =>
x.Status == AddEventStatus.WaitForJoin &&
x.ComponentControl.IsFake() == false &&
x.LastAttempSendOrJoinDate <= date)
.OrderBy(x => x.Errors)
.Take(maxJoinCount)
.ToList();
// создаем задачи для отправки
foreach (var bufferEventData in sendEvents)
{
BufferEventData data = bufferEventData;
TaskQueue.Add(() => SendOneEvent(data));
}
// создаем задачи для склейки
if (joinEvents.Any(x => x.ComponentControl.Info == null))
{
throw new Exception("joinEvents.Any(x => x.ComponentControl.Info == null)");
}
joinEvents = joinEvents.OrderBy(x => x.ComponentControl.Info.Id).ToList();
const int batchCount = 20;// будем продлевать 20 событий за раз
var batchEvents = new List <BufferEventData>(batchCount);
foreach (var bufferEventData in joinEvents)
{
batchEvents.Add(bufferEventData);
if (batchEvents.Count == batchCount)
{
var tempEvents1 = new List <BufferEventData>();
tempEvents1.AddRange(batchEvents);
TaskQueue.Add(() => JoinEvents(tempEvents1));
batchEvents.Clear();
}
}
if (batchEvents.Count > 0)
{
var tempEvents = new List <BufferEventData>();
tempEvents.AddRange(batchEvents);
TaskQueue.Add(() => JoinEvents(tempEvents));
}
}
catch (Exception exception)
{
Client.InternalLog.Error("Ошибка обработки очереди событий", exception);
}
}
public override void CreateTaskQueue()
{
TaskQueue.Add(new Unpacker(AsmDef));
Deobfuscate();
}
public void V(string message, [CallerMemberName] string callMemberName = null)
{
var task = GenerateTask("V", TAG, className, callMemberName, message);
TaskQueue.Enqueue(task);
}
public VirtualExchange(TaskQueue taskQueue)
{
_taskQueue = taskQueue;
}
public async ValueTask SynchronizeWithBuildAsync(
ImmutableDictionary <ProjectId,
ImmutableArray <DiagnosticData> > buildDiagnostics,
TaskQueue postBuildAndErrorListRefreshTaskQueue,
bool onBuildCompleted,
CancellationToken cancellationToken)
{
var options = Workspace.Options;
using (Logger.LogBlock(FunctionId.DiagnosticIncrementalAnalyzer_SynchronizeWithBuildAsync, LogSynchronizeWithBuild, options, buildDiagnostics, cancellationToken))
{
DebugVerifyDiagnosticLocations(buildDiagnostics);
if (!PreferBuildErrors(options))
{
// Prefer live errors over build errors
return;
}
var solution = Workspace.CurrentSolution;
foreach (var(projectId, diagnostics) in buildDiagnostics)
{
cancellationToken.ThrowIfCancellationRequested();
var project = solution.GetProject(projectId);
if (project == null)
{
continue;
}
var stateSets = _stateManager.CreateBuildOnlyProjectStateSet(project);
var newResult = CreateAnalysisResults(project, stateSets, diagnostics);
// PERF: Save the diagnostics into in-memory cache on the main thread.
// Saving them into persistent storage is expensive, so we invoke that operation on a separate task queue
// to ensure faster error list refresh.
foreach (var stateSet in stateSets)
{
cancellationToken.ThrowIfCancellationRequested();
var state = stateSet.GetOrCreateProjectState(project.Id);
var result = GetResultOrEmpty(newResult, stateSet.Analyzer, project.Id, VersionStamp.Default);
await state.SaveToInMemoryStorageAsync(project, result).ConfigureAwait(false);
}
// Raise diagnostic updated events after the new diagnostics have been stored into the in-memory cache.
if (diagnostics.IsEmpty)
{
ClearAllDiagnostics(stateSets, projectId);
}
else
{
RaiseProjectDiagnosticsIfNeeded(project, stateSets, newResult);
}
}
// Refresh live diagnostics after solution build completes.
if (onBuildCompleted && PreferLiveErrorsOnOpenedFiles(options))
{
// Enqueue re-analysis of active document with high-priority right away.
if (_documentTrackingService.GetActiveDocument(solution) is { } activeDocument)
{
AnalyzerService.Reanalyze(Workspace, documentIds: ImmutableArray.Create(activeDocument.Id), highPriority: true);
}
// Enqueue remaining re-analysis with normal priority on a separate task queue
// that will execute at the end of all the post build and error list refresh tasks.
_ = postBuildAndErrorListRefreshTaskQueue.ScheduleTask(nameof(SynchronizeWithBuildAsync), () =>
{
// Enqueue re-analysis of open documents.
AnalyzerService.Reanalyze(Workspace, documentIds: Workspace.GetOpenDocumentIds());
// Enqueue re-analysis of projects, if required.
foreach (var projectsByLanguage in solution.Projects.GroupBy(p => p.Language))
{
if (SolutionCrawlerOptions.GetBackgroundAnalysisScope(Workspace.Options, projectsByLanguage.Key) == BackgroundAnalysisScope.FullSolution)
{
AnalyzerService.Reanalyze(Workspace, projectsByLanguage.Select(p => p.Id));
}
}
}, cancellationToken);
}
}
}
public GlobalOperationNotificationService(IAsynchronousOperationListener listener)
{
_eventQueue = new TaskQueue(listener, TaskScheduler.Default);
}
