/// <summary>
/// Initializes a new instance of the <see cref="AsynchronousTraceListenerWrapper" /> class.
/// </summary>
/// <param name="wrappedTraceListener">The wrapped trace listener.</param>
/// <param name="ownsWrappedTraceListener">Indicates whether the wrapper should dispose the wrapped trace listener.</param>
/// <param name="bufferSize">Size of the buffer for asynchronous requests.</param>
/// <param name="maxDegreeOfParallelism">The max degree of parallelism for thread safe listeners. Specify <see langword="null"/> to use the current core count.</param>
/// <param name="disposeTimeout">The timeout for waiting to complete buffered requests when disposing. When <see langword="null" /> the default of <see cref="Timeout.InfiniteTimeSpan" /> is used.</param>
public AsynchronousTraceListenerWrapper(
TraceListener wrappedTraceListener,
bool ownsWrappedTraceListener = true,
int? bufferSize = DefaultBufferSize,
int? maxDegreeOfParallelism = null,
TimeSpan? disposeTimeout = null)
{
Guard.ArgumentNotNull(wrappedTraceListener, "wrappedTraceListener");
CheckBufferSize(bufferSize);
CheckMaxDegreeOfParallelism(maxDegreeOfParallelism);
CheckDisposeTimeout(disposeTimeout);
this.wrappedTraceListener = wrappedTraceListener;
this.ownsWrappedTraceListener = ownsWrappedTraceListener;
this.disposeTimeout = disposeTimeout ?? Timeout.InfiniteTimeSpan;
this.closeSource = new CancellationTokenSource();
this.requests = bufferSize != null ? new BlockingCollection<Action<TraceListener>>(bufferSize.Value) : new BlockingCollection<Action<TraceListener>>();
if (this.wrappedTraceListener.IsThreadSafe)
{
this.maxDegreeOfParallelism = maxDegreeOfParallelism.HasValue ? maxDegreeOfParallelism.Value : Environment.ProcessorCount;
this.asyncProcessingTask = Task.Factory.StartNew(this.ProcessRequestsInParallel, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
else
{
this.asyncProcessingTask = Task.Factory.StartNew(this.ProcessRequests, CancellationToken.None, TaskCreationOptions.HideScheduler | TaskCreationOptions.LongRunning, TaskScheduler.Default);
}
}
public CommandProcessor(ICommandProcessingStrategy processingStrategy,
ICommandQueue commandQueue)
{
_processingStrategy = processingStrategy;
_commandQueue = commandQueue;
_cancellationTokenSource = new CancellationTokenSource();
var token = _cancellationTokenSource.Token;
var task = new Task(
() =>
{
while (!token.IsCancellationRequested)
{
var cmd = _commandQueue.Dequeue();
while (cmd != null)
{
_processingStrategy.ProcessCommand(cmd.Execute);
cmd = commandQueue.Dequeue();
}
Thread.Sleep(100);
}
},
token,
TaskCreationOptions.LongRunning);
task.Start();
}
public static IYubicoResponse Validate(IEnumerable<string> urls, string userAgent)
{
var tasks = new List<Task<IYubicoResponse>>();
var cancellation = new CancellationTokenSource();
foreach (var url in urls)
{
var thisUrl = url;
var task = new Task<IYubicoResponse>(() => DoVerify(thisUrl, userAgent), cancellation.Token);
task.ContinueWith(t => { }, TaskContinuationOptions.OnlyOnFaulted);
tasks.Add(task);
task.Start();
}
while (tasks.Count != 0)
{
// TODO: handle exceptions from the verify task. Better to be able to propagate cause for error.
var completed = Task.WaitAny(tasks.Cast<Task>().ToArray());
var task = tasks[completed];
tasks.Remove(task);
if (task.Result != null)
{
cancellation.Cancel();
return task.Result;
}
}
return null;
}
public void Start()
{
_source = new CancellationTokenSource();
var token = _source.Token;
_listenerTask = new Task(() =>
{
BusListener.MessageReceivedEvent += (s, e) => Console.WriteLine("Received message at " + e.Endpoint + " of type " + e.MessageType);
BusListener.MessageSentEvent += (s, e) => Console.WriteLine("Sent message " + e.MessageType);
BusListener.BusStartedEvent += (s, e) => Console.WriteLine("Bus started " + e.Endpoint);
BusListener.MessageExceptionEvent += (s, e) => Console.WriteLine("Exception with message " + e.Endpoint + " for type " + e.MessageType + " with value " + e.Exception);
using (var host = new ServiceHost(_listener, new[] { new Uri("net.tcp://localhost:5050") }))
{
host.AddServiceEndpoint(typeof(IBusListener), new NetTcpBinding(), "NServiceBus.Diagnostics");
host.Opened += (s, e) => Console.WriteLine("Listening for events...");
host.Closed += (s, e) => Console.WriteLine("Closed listening for events...");
host.Open();
while (!token.IsCancellationRequested) { }
host.Close();
}
}, token);
_listenerTask.Start();
_listenerTask.Wait(10000);
}
private async Task Polling()
{
while (true)
{
try
{
if (cancellationToken.IsCancellationRequested)
break;
var list = sources;
var tasks = new Task<IDictionary<string,object>>[list.Count];
for (int i = 0; i < list.Count; i++)
{
tasks[i] = list[i].LoadProperties(cancellationToken.Token);
}
if(!Task.WaitAll(tasks, sourceTimeoutInMs, cancellationToken.Token))
{
// log : one task is timeout
}
LoadPropertiesFromSources(tasks);
await Task.Delay(PollingIntervalInSeconds*1000, cancellationToken.Token);
}
catch (OperationCanceledException)
{
break;
}
catch (Exception)
{
// log
}
}
}
public Promise(Arguments args)
{
m_promiseTask = new Task<JSObject>(() =>
{
return Undefined;
});
}
/// <summary>
/// Blocks the calling thread to pump messages until a task has completed.
/// </summary>
/// <param name="untilCompleted">The task that must complete to break out of the message loop.</param>
public void PumpMessages(Task untilCompleted)
{
this.VerifyState();
this.pumping = true;
try
{
// Arrange to wake up immediately when the task completes.
untilCompleted.ContinueWith(
_ =>
{
lock (this.messageQueue)
{
Monitor.Pulse(this.messageQueue);
}
},
TaskScheduler.Default);
// Now run the message loop until the task completes.
while (!untilCompleted.IsCompleted)
{
this.TryOneWorkItem();
}
}
finally
{
this.pumping = false;
}
}
public void NUnitTestShouldDependOnDlls()
{
var paths = new Task<string> [] {"one", "two"};
var tests = new NUnitTests {DllPaths = paths};
Assert.That(tests.Dependencies.Select(d => d.Task), Has.Member(paths[0]).And.Member(paths[1]));
}
public void Enable()
{
lock (_gate)
{
if (_instanceTask != null)
{
// already enabled
return;
}
if (!_workspace.Options.GetOption(RemoteHostOptions.RemoteHost))
{
// not turned on
return;
}
var remoteHostClientFactory = _workspace.Services.GetService<IRemoteHostClientFactory>();
if (remoteHostClientFactory == null)
{
// dev14 doesn't have remote host client factory
return;
}
// make sure we run it on background thread
_shutdownCancellationTokenSource = new CancellationTokenSource();
var token = _shutdownCancellationTokenSource.Token;
_instanceTask = Task.Run(() => EnableAsync(token), token);
}
}
public void Disable()
{
lock (_gate)
{
if (_instanceTask == null)
{
// already disabled
return;
}
var instance = _instanceTask;
_instanceTask = null;
RemoveGlobalAssets();
_shutdownCancellationTokenSource.Cancel();
try
{
instance.Wait(_shutdownCancellationTokenSource.Token);
instance.Result.Shutdown();
}
catch (OperationCanceledException)
{
// _instance wasn't finished running yet.
}
}
}
public AssemblyLoader (AssemblyBrowserWidget widget, string fileName)
{
if (widget == null)
throw new ArgumentNullException ("widget");
if (fileName == null)
throw new ArgumentNullException ("fileName");
this.widget = widget;
this.FileName = fileName;
if (!File.Exists (fileName))
throw new ArgumentException ("File doesn't exist.", "fileName");
this.assemblyLoaderTask = Task.Factory.StartNew<AssemblyDefinition> (() => {
try {
return AssemblyDefinition.ReadAssembly (FileName, new ReaderParameters {
AssemblyResolver = this
});
} catch (Exception e) {
LoggingService.LogError ("Error while reading assembly " + FileName, e);
return null;
}
}, src.Token);
this.unresolvedAssembly = new Lazy<IUnresolvedAssembly> (delegate {
try {
return widget.CecilLoader.LoadAssembly (Assembly);
} catch (Exception e) {
LoggingService.LogError ("Error while loading assembly", e);
return new ICSharpCode.NRefactory.TypeSystem.Implementation.DefaultUnresolvedAssembly (FileName);
}
});
}
public override void Save(SaveMetrics metrics, bool permitBackgroundWrite)
{
_metrics = metrics;
OpenFiles();
var saveTasks = new Task[4];
saveTasks[0] = SaveItems();
saveTasks[1] = SaveMobiles();
saveTasks[2] = SaveGuilds();
saveTasks[3] = SaveData();
SaveTypeDatabases();
if (permitBackgroundWrite)
{
//This option makes it finish the writing to disk in the background, continuing even after Save() returns.
Task.Factory.ContinueWhenAll(
saveTasks,
_ =>
{
CloseFiles();
World.NotifyDiskWriteComplete();
});
}
else
{
Task.WaitAll(saveTasks); //Waits for the completion of all of the tasks(committing to disk)
CloseFiles();
}
}
private static async Task CancelAllWhenAnyCompletes(Task leaderTask, Task renewLeaseTask, CancellationTokenSource cts)
{
await Task.WhenAny(leaderTask, renewLeaseTask);
// Cancel the user's leader task or the renewLease Task, as it is no longer the leader.
cts.Cancel();
var allTasks = Task.WhenAll(leaderTask, renewLeaseTask);
try
{
await Task.WhenAll(allTasks);
}
catch (Exception)
{
if (allTasks.Exception != null)
{
allTasks.Exception.Handle(ex =>
{
if (!(ex is OperationCanceledException))
{
Trace.TraceError(ex.Message);
}
return true;
});
}
}
}
static void Main(string[] args)
{
var maxPlayers = 6;
var rand = new Random();
while (true)
{
var numOfPlayers = rand.Next(maxPlayers / 2, maxPlayers);
Task[] tasks = new Task[numOfPlayers];
for (int j = 0; j < numOfPlayers; j++)
{
int j1 = j;
tasks[j] = Task.Factory.StartNew(() => Target(new ThreadParams()
{
MaxUsers=numOfPlayers,
Seed = j1 * 6,
State = (j1 == 0 ? (ThreadState.CreateGame) : ThreadState.JoinGame),
UserName = names[j1]
}));
}
while (tasks.Any(t => !t.IsCompleted)) { } //spin wait
}
}
public Promise(Task<JSObject> task)
{
if (task == null)
throw new ArgumentNullException("task");
m_promiseTask = task;
}
public void AddOnChangeSetSuccessTask(Task onSuccessTask)
{
lock (this)
{
_onSuccessTasks.Add(onSuccessTask);
}
}
public void Start()
{
if (_running)
return;
_running = true;
_httpTask = Task.Run(() => RunTask(), _cts.Token);
}
public void AddOnChangeSetFailureTask(Task onFailureTask)
{
lock (this)
{
_onFailureTasks.Add(onFailureTask);
}
}
/// <summary>
/// 创建对象
/// </summary>
/// <param name="name">测试名称</param>
/// <param name="threads">线程数</param>
/// <param name="iteration">循环数</param>
/// <param name="action">测试方法</param>
public static void Time(string name, int threads, int iteration, Action action)
{
Console.ForegroundColor = ConsoleColor.Green;
Console.WriteLine("{0} {1}", name, DateTime.Now.ToString("yyyy-M-d hh:mm:ss"));
Console.ForegroundColor = ConsoleColor.White;
action();
Thread.Sleep(1);
Display("GO");
//
WorkerStat[] statArray = new WorkerStat[threads];
Task[] taskArray = new Task[threads];
WorkerStat mainStat = new WorkerStat { RunCount = threads * iteration };
DateTime before = DateTime.Now;
//Stopwatch watch = Stopwatch.StartNew();
for (int i = 0; i < threads; i++)
{
statArray[i] = new WorkerStat()
{
RunCount = iteration
};
taskArray[i] = Task.Factory.StartNew(new TaskExt(statArray[i], action).Run);
}
Task.WaitAll(taskArray);
TimeSpan timeTaken = DateTime.Now - before;
//watch.Stop();
mainStat.Timespan = (long)timeTaken.TotalMilliseconds;
WorkerStat totalStat = new WorkerStat();
for (int i = 0; i < threads; i++)
{
totalStat.RunCount = totalStat.RunCount + statArray[i].RunCount;
totalStat.Timespan = totalStat.Timespan + statArray[i].Timespan;
}
//---
DisplayTestResult(name, threads, iteration, mainStat, totalStat);
}
public void FinishAccept(byte[] buffer, int offset, int length, IPEndPoint remoteEndPoint, IPEndPoint localEndPoint)
{
_remoteEndPoint = remoteEndPoint;
_localEndPoint = localEndPoint;
Debug.Assert(length == 0);
try
{
_ssl = new SslStream(_inputStream, true);
_authenticateTask = _ssl.AuthenticateAsServerAsync(_serverCertificate, false, _protocols, false).ContinueWith((t, selfObject) =>
{
var self = (SslTransportHandler)selfObject;
if (t.IsFaulted || t.IsCanceled)
self._next.FinishAccept(null, 0, 0, null, null);
else
self._ssl.ReadAsync(self._recvBuffer, self._recvOffset, self._recvLength).ContinueWith((t2, selfObject2) =>
{
var self2 = (SslTransportHandler)selfObject2;
if (t2.IsFaulted || t2.IsCanceled)
self2._next.FinishAccept(null, 0, 0, null, null);
else
self2._next.FinishAccept(self2._recvBuffer, self2._recvOffset, t2.Result, self2._remoteEndPoint, self2._localEndPoint);
}, self);
}, this);
}
catch (Exception)
{
Callback.StartDisconnect();
}
}
public static void Add(RecursiveAsyncLock mutex, Task<IDisposable> key)
{
Tuple<int, Task<IDisposable>> value;
if (!OwnedLocks.TryGetValue(mutex, out value))
value = Tuple.Create(0, key);
OwnedLocks = OwnedLocks.SetItem(mutex, Tuple.Create(value.Item1 + 1, value.Item2));
}
static void Main()
{
Task t = new Task(DownloadPageAsync);
t.Start();
Console.WriteLine("Downloading page...");
Console.ReadLine();
}
protected override bool TryExecuteTaskInline (Task task, bool taskWasPreviouslyQueued)
{
if (TryExecuteTaskInlineHandler != null)
TryExecuteTaskInlineHandler (task, taskWasPreviouslyQueued);
return base.TryExecuteTask (task);
}
protected override void QueueTask (Task task)
{
Interlocked.Increment (ref qc);
ThreadPool.QueueUserWorkItem (o => {
TryExecuteTask (task);
});
}
/// <summary>
/// Implementación para la demostración del flujo de control de invocaciones
/// a través de elementos de programa de TPL.
/// </summary>
/// <returns>Resultado de la operación asincrónica.</returns>
private Task AsincronismoConTpl()
{
var tareaCompuesta = new Task(() =>
{
Task<string> tarea1 = ObtenerInfoThreadAsync("TPL No. 1");
tarea1.ContinueWith(tarea =>
{
Console.WriteLine(tarea1.Result);
Task<string> tarea2 = ObtenerInfoThreadAsync("TPL No. 2");
tarea2.ContinueWith(tareaAnidada =>
Console.WriteLine(tareaAnidada.Result),
TaskContinuationOptions.NotOnFaulted |
TaskContinuationOptions.AttachedToParent);
tarea2.ContinueWith(tareaAnidada =>
Console.WriteLine(tareaAnidada.Exception.InnerException),
TaskContinuationOptions.OnlyOnFaulted |
TaskContinuationOptions.AttachedToParent);
},
TaskContinuationOptions.NotOnFaulted |
TaskContinuationOptions.AttachedToParent);
tarea1.ContinueWith(tarea =>
Console.WriteLine(tarea1.Exception.InnerException),
TaskContinuationOptions.OnlyOnFaulted |
TaskContinuationOptions.AttachedToParent);
});
tareaCompuesta.Start();
return tareaCompuesta;
}
/// <summary>
/// Starts the listening for updates and fires a <see cref="OnMessageReceived"/> event when a message is received.
/// </summary>
/// <param name="pollingInterval">The interval of polling in seconds (default set)</param>
public void Start(int pollingInterval = 1)
{
if (_getUpdatesTask != null) return;
try
{
Action poll = async () =>
{
while (!_cancellationTokenSource.IsCancellationRequested)
{
Update[] updates = await GetUpdatesAsync(_lastUpdateId, timeout: pollingInterval);
foreach (Update update in updates.Where(u => u.UpdateId > _lastUpdateId))
{
FireMessageReceived(update.Message);
_lastUpdateId = update.UpdateId;
}
//await Task.Delay(pollingInterval * 1000);
}
};
_getUpdatesTask = Task.Run(poll, _cancellationTokenSource.Token);
}
catch (Exception ex)
{
Debug.WriteLine(ex.Message);
}
}
protected void DropDownListMark_SelectedIndexChanged(object sender, EventArgs e)
{
bool status = false;
foreach (GridViewRow row in GridViewTask.Rows)
{
CheckBox checkBox = (CheckBox)row.Cells[0].FindControl("CheckBoxTask");
if (checkBox.Checked)
{
HiddenField hiddenField = (HiddenField)row.Cells[0].FindControl("HiddenFieldTask");
string taskUserOID = hiddenField.Value;
Task task = new Task();
if ((DropDownListMark.SelectedItem.Text == "Mark") || (DropDownListMark.SelectedItem.Text == "Star"))
{
if (task.UpdateTaskUserUMark(Convert.ToInt32(taskUserOID), 1)) status = true;
}
else
{
if (task.UpdateTaskUserUStatus(Convert.ToInt32(taskUserOID), DropDownListMark.SelectedItem.Text)) status = true;
}
}
}
if (status)
{
PopulateGridview();
}
}
//called when data for any output pin is requested
public void Evaluate(int SpreadMax)
{
if(FInput.IsChanged)
{
FOutput.SliceCount = FInput.SliceCount;
for (int i = 0; i < FInput.SliceCount; i++) {
var r = new TRes();
r.host = FInput[i];
r.idx = i;
r.Resolved = false;
var t = new Task<TRes>(() => _GetHostByName(r));
var c = t.ContinueWith((res) =>
{
if(res.Result.ips != null)
{
FOutput[res.Result.idx].SliceCount = res.Result.ips.Length;
for(int j = 0; j<res.Result.ips.Length;j++)
{
FOutput[res.Result.idx][j] = res.Result.ips[j];
}
} else FOutput[res.Result.idx].SliceCount = 0;
},TaskContinuationOptions.OnlyOnRanToCompletion);
t.Start();
}
}
//FLogger.Log(LogType.Debug, "Logging to Renderer (TTY)");
}
public static void Start(string name)
{
DBC.Pre(!string.IsNullOrEmpty(name), "name is null or empty");
if (ms_current == null)
{
DBC.Assert(ms_root == null, "Start was called after the root task was stopped");
ms_root = new Task(null, name);
ms_current = ms_root;
}
else
{
Task task;
if (!ms_current.SubTasks.TryGetValue(name, out task))
{
task = new Task(ms_current, name);
ms_current.SubTasks.Add(name, task);
}
else
{
DBC.Assert(task.StartTime == DateTime.MinValue, "can't nest the same task");
task.StartTime = DateTime.Now;
task.Count += 1;
}
ms_current = task;
}
}
public async Task Stop()
{
await _startStopSemaphore.WaitAsync();
try
{
if (!_running) return;
_running = false;
_cancellationTokenSource.Cancel();
_cancellationTokenSource = null;
var workerTask = _workerTask;
_workerTask = null;
if (workerTask != null) await workerTask;
// wait for all our existing tasks to complete
//FIXME a bit ick..
while (_throttle.CurrentCount < ConcurrentHandlerLimit)
{
await Task.Delay(TimeSpan.FromMilliseconds(100));
}
}
finally
{
_startStopSemaphore.Release();
}
}
/// <summary>
/// This method is called during suspected data loss.
/// You can override this method to restore the service in case of data loss.
/// </summary>
/// <param name="restoreCtx">
/// A <see cref="RestoreContext"/> to be used to restore the service.
/// </param>
/// <param name="cancellationToken">
/// <see cref="CancellationToken"/> to monitor for cancellation requests.
/// </param>
/// <returns>
/// A Task that represents the asynchronous restore operation.
/// True indicates that the state has been restored.
/// False indicates that the replica's state has not been modified.
/// </returns>
protected virtual Task<bool> OnDataLossAsync(RestoreContext restoreCtx, CancellationToken cancellationToken)
{
return Task.FromResult(false);
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your SMS service here to send a text message.
return Task.FromResult(0);
}
protected RedirectToRouteResult RedirectToActionPermanent(Task <ActionResult> taskResult)
{
return(RedirectToActionPermanent(taskResult.Result));
}
public Task<byte[]> Decompress(byte[] compressedArray, int bufferSize)
{
return Task.FromResult(compressedArray);
}
/// <inheritdoc/>
public Task<IEnumerable<string>> GetAvailableDifficultyLevelsAsync()
{
return Task.FromResult(levelsProvider.GetLevels());
}
public async Task<TestingSystemResponse> CheckSolution(SolutionTestingRequest solutionRequest)
{
try
{
var solution = _db.Solutions.Find(solutionRequest.SolutionId);
if (solution != null && solution.File != null)
{
var taskTests = _db.TaskTests.Where(t => t.TaskId == solution.TaskId).ToArray();
if (taskTests != null && taskTests.Length > 0)
{
var isAlive = await CheckIfAlive(_config.CompilerServicesOrchestrator);
if (isAlive)
{
//var dataBytes = await file.GetBytes();
var codeStyleTask = taskTests.FirstOrDefault(t => t.TestType == "codeStyleTest");
var req = new TestRequest
{
SolutionId = solutionRequest.SolutionId,
TestId = codeStyleTask is null ? -1 : codeStyleTask.Id,
ReCheck = solutionRequest.ReCheck,
};
string url = _config.CompilerServicesOrchestrator.GetFullTestLinkFrom(_config.TestingSystemWorker);
using var httpClient = new HttpClient();
using var form = JsonContent.Create(req);
HttpResponseMessage response = await httpClient.PostAsync(url, form);
string apiResponse = await response.Content.ReadAsStringAsync();
if (response.IsSuccessStatusCode)
{
TestResponse compResponse = JsonConvert.DeserializeObject<TestResponse>(apiResponse);
if (compResponse.OK && compResponse.Result == ResultCode.OK)
{
var compResult = _db.CompilationResults.Find(solutionRequest.SolutionId);
if (compResult != null)
{
if (compResult.ResultCode != ResultCode.CE && compResult.File != null)
{
var testTasks = new List<Task<TestResponse>>();
foreach (var test in taskTests)
{
if (_config.Tests.ContainsKey(test.TestType))
{
testTasks.Add(StartTest(test.TestType, solutionRequest.SolutionId, test.Id, solutionRequest.ReCheck));
}
else
{
testTasks.Add(Task.Run(() => NoTestFound(test.TestType, solutionRequest.SolutionId, test.Id)));
}
}
await Task.WhenAll(testTasks);
var responses = testTasks.Select(t => t.Result).ToArray();
var results = responses.Join(taskTests, i => i.TestId, o => o.Id, (i, o) => new { Result = i, Definition = o }).ToArray();
double totalScore = 0;
ResultCode totalResult = results.Select(r => r.Result.Result).Max();
foreach (var res in results)
{
if (res.Definition.Block && res.Result.Score == 0)
{
totalScore = 0;
break;
}
else
{
totalScore += res.Result.Score * res.Definition.Weight;
}
}
return WriteToDb(solution, totalResult, totalScore, "success", true, responses);
}
else
{
return WriteToDb(solution, compResult.ResultCode, 0, "compilation error!", true);
}
}
else
{
return WriteToDb(solution, compResponse.Result, 0, "can't find compilation! Inner message: " + compResponse.Message, false);
}
}
else
{
return WriteToDb(solution, compResponse.Result, 0, "something went wrong during compilation! Inner message: " + compResponse.Message, false);
}
}
else
{
return WriteToDb(solution, ResultCode.IE, 0, "bad response from compilation container: " + response.StatusCode, false);
}
}
else
{
return WriteToDb(solution, ResultCode.IE, 0, "Compiler Service Is Dead!", false);
}
}
else
{
return WriteToDb(null, ResultCode.IE, 0, "Can't find task tests!", false);
}
}
else
{
return WriteToDb(null, ResultCode.IE, 0, "Can't find solution!", false);
}
}
catch
{
return new TestingSystemResponse();
}
}
public async Task Slot(ShmartNumber amount)
{
if (!_runningUsers.Add(Context.User.Id))
{
return;
}
try
{
if (!await CheckBetMandatory(amount).ConfigureAwait(false))
{
return;
}
const int maxAmount = 9999;
if (amount > maxAmount)
{
await ReplyErrorLocalizedAsync("max_bet_limit", maxAmount + Bc.BotConfig.CurrencySign).ConfigureAwait(false);
return;
}
if (!await _cs.RemoveAsync(Context.User, "Slot Machine", amount, false, gamble: true).ConfigureAwait(false))
{
await ReplyErrorLocalizedAsync("not_enough", Bc.BotConfig.CurrencySign).ConfigureAwait(false);
return;
}
Interlocked.Add(ref _totalBet, amount.Value);
using (var bgImage = Image.Load(_images.SlotBackground))
{
var result = SlotMachine.Pull();
int[] numbers = result.Numbers;
for (int i = 0; i < 3; i++)
{
using (var randomImage = Image.Load(_images.SlotEmojis[numbers[i]]))
{
bgImage.Mutate(x => x.DrawImage(GraphicsOptions.Default, randomImage, new Point(95 + 142 * i, 330)));
}
}
var won = amount * result.Multiplier;
var printWon = won;
var n = 0;
do
{
var digit = (int)(printWon % 10);
using (var img = Image.Load(_images.SlotNumbers[digit]))
{
bgImage.Mutate(x => x.DrawImage(GraphicsOptions.Default, img, new Point(230 - n * 16, 462)));
}
n++;
} while ((printWon /= 10) != 0);
var printAmount = amount;
n = 0;
do
{
var digit = (int)(printAmount % 10);
using (var img = Image.Load(_images.SlotNumbers[digit]))
{
bgImage.Mutate(x => x.DrawImage(GraphicsOptions.Default, img, new Point(395 - n * 16, 462)));
}
n++;
} while ((printAmount /= 10) != 0);
var msg = GetText("better_luck");
if (result.Multiplier != 0)
{
await _cs.AddAsync(Context.User, $"Slot Machine x{result.Multiplier}", amount *result.Multiplier, false, gamble : true).ConfigureAwait(false);
Interlocked.Add(ref _totalPaidOut, amount * result.Multiplier);
if (result.Multiplier == 1)
{
msg = GetText("slot_single", Bc.BotConfig.CurrencySign, 1);
}
else if (result.Multiplier == 4)
{
msg = GetText("slot_two", Bc.BotConfig.CurrencySign, 4);
}
else if (result.Multiplier == 10)
{
msg = GetText("slot_three", 10);
}
else if (result.Multiplier == 30)
{
msg = GetText("slot_jackpot", 30);
}
}
using (var imgStream = bgImage.ToStream())
{
await Context.Channel.SendFileAsync(imgStream, "result.png", Context.User.Mention + " " + msg + $"\n`{GetText("slot_bet")}:`{amount} `{GetText("won")}:` {amount * result.Multiplier}{Bc.BotConfig.CurrencySign}").ConfigureAwait(false);
}
}
}
finally
{
var _ = Task.Run(async() =>
{
await Task.Delay(1500).ConfigureAwait(false);
_runningUsers.Remove(Context.User.Id);
});
}
}
public void Send(ref System.Diagnostics.Stopwatch sw)
{
sw.Start();
Task.WaitAll(mSend());
}
public Task<PackageVerificationCode> VerifyPackageAsync()
{
return Task.Run(() =>
{
ModuleTypesList type; float MinimalVersion;
using (ZipArchive zip_content = ZipFile.OpenRead(Package.Path))
{
//Verify "infos.json" and if the file exist, get the content for the others verification !
try
{
ZipArchiveEntry InfosJson = zip_content.GetEntry("infos.json");
if (InfosJson == null)
{
return PackageVerificationCode.InfosJsonNotFound;
}
else
{
using (var reader = new StreamReader(InfosJson.Open()))
using (JsonReader JsonReader = new JsonTextReader(reader))
{
InfosModule module = new JsonSerializer().Deserialize<InfosModule>(JsonReader);
if (module != null)
{
type = module.ModuleType;
MinimalVersion = module.SceMinimalVersionRequired;
}
else
{
return PackageVerificationCode.InfosJsonNotFound;
}
}
}
}
catch
{
return PackageVerificationCode.InfosJsonNotFound;
}
//Verify if the logo exist or not
try
{
if (zip_content.GetEntry("logo.png") == null)
{
return PackageVerificationCode.LogoNotFound;
}
}
catch
{
return PackageVerificationCode.LogoNotFound;
}
//Verify if the icon exist or not
try
{
if (zip_content.GetEntry("icon.png") == null)
{
return PackageVerificationCode.LogoNotFound;
}
}
catch
{
return PackageVerificationCode.LogoNotFound;
}
switch (type)
{
case ModuleTypesList.Templates:
case ModuleTypesList.Addon:
//Verify if the "main.js" exist or not
try
{
if (zip_content.GetEntry("main.js") == null)
{
return PackageVerificationCode.MainJsNotFound;
}
}
catch { return PackageVerificationCode.MainJsNotFound; }
break;
case ModuleTypesList.Theme:
//Verify if the "theme.js" or "theme_ace.js" exist or not
bool themejs = true, themeacejs = true;
try
{
if (zip_content.GetEntry("theme.json") == null)
{
themejs = false;
}
}
catch
{
themejs = false;
}
/*try
{
if (zip_content.GetEntry("theme_ace.js") == null)
{
themeacejs = false;
}
}
catch
{
themeacejs = false;
}*/
if (!themejs /*&& !themeacejs*/)
{
return PackageVerificationCode.NoThemeFiles;
}
break;
case ModuleTypesList.ProgrammingLanguage:
try
{
if (zip_content.GetEntry("language.js") == null)
{
return PackageVerificationCode.NoProgLanguagesFiles;
}
}
catch
{
return PackageVerificationCode.NoProgLanguagesFiles;
}
break;
}
}
return PackageVerificationCode.Passed;
});
}
public Task SendAsync(IdentityMessage message)
{
// Plug in your email service here to send an email.
return Task.FromResult(0);
}
private void buttonApprox_Click(object sender, EventArgs e)
{
//Слово для поиска
string word = this.textBoxFind.Text.Trim();
//Если слово для поиска не пусто
if (!string.IsNullOrWhiteSpace(word) && list.Count > 0)
{
int maxDist;
if (!int.TryParse(this.textBoxMaxDist.Text.Trim(), out maxDist))
{
MessageBox.Show("Необходимо указать максимальное расстояние");
return;
}
if (maxDist < 1 || maxDist > 5)
{
MessageBox.Show("Максимальное расстояние должно быть в диапазоне от 1 до 5");
return;
}
int ThreadCount;
if (!int.TryParse(this.textBoxThreadCount.Text.Trim(), out ThreadCount))
{
MessageBox.Show("Необходимо указать количество потоков");
return;
}
Stopwatch timer = new Stopwatch();
timer.Start();
//-------------------------------------------------
// Начало параллельного поиска
//-------------------------------------------------
//Результирующий список
List <ParallelSearchResult> Result = new List <ParallelSearchResult>();
//Деление списка на фрагменты для параллельного запуска в потоках
List <MinMax> arrayDivList = SubArrays.DivideSubArrays(0, list.Count, ThreadCount);
int count = arrayDivList.Count;
//Количество потоков соответствует количеству фрагментов массива
Task <List <ParallelSearchResult> >[] tasks = new Task <List <ParallelSearchResult> > [count];
//Запуск потоков
for (int i = 0; i < count; i++)
{
//Создание временного списка, чтобы потоки не работали параллельно с одной коллекцией
List <string> tempTaskList = list.GetRange(arrayDivList[i].Min, arrayDivList[i].Max - arrayDivList[i].Min);
tasks[i] = new Task <List <ParallelSearchResult> >(
//Метод, который будет выполняться в потоке
ArrayThreadTask,
//Параметры потока
new ParallelSearchThreadParam()
{
tempList = tempTaskList,
maxDist = maxDist,
ThreadNum = i,
wordPattern = word
});
//Запуск потока
tasks[i].Start();
}
Task.WaitAll(tasks);
timer.Stop();
//Объединение результатов
for (int i = 0; i < count; i++)
{
Result.AddRange(tasks[i].Result);
}
//-------------------------------------------------
// Завершение параллельного поиска
//-------------------------------------------------
timer.Stop();
//Вывод результатов
//Время поиска
this.textBoxApproxTime.Text = timer.Elapsed.ToString();
//Вычисленное количество потоков
this.textBoxThreadCountAll.Text = count.ToString();
//Начало обновления списка результатов
this.listBoxResult.BeginUpdate();
//Очистка списка
this.listBoxResult.Items.Clear();
//Вывод результатов поиска
foreach (var x in Result)
{
string temp = x.word + "(расстояние=" + x.dist.ToString() + " поток=" + x.ThreadNum.ToString() + ")";
this.listBoxResult.Items.Add(temp);
}
//Окончание обновления списка результатов
this.listBoxResult.EndUpdate();
}
else
{
MessageBox.Show("Необходимо выбрать файл и ввести слово для поиска");
}
}
public async Task CreatesPackageOwnerRequestSendsEmailAndReturnsPendingState(Func <Fakes, User> getCurrentUser, Func <Fakes, User> getUserToAdd)
{
var fakes = Get <Fakes>();
var currentUser = getCurrentUser(fakes);
var userToAdd = getUserToAdd(fakes);
var controller = GetController <JsonApiController>();
controller.SetCurrentUser(currentUser);
var packageOwnershipManagementServiceMock = GetMock <IPackageOwnershipManagementService>();
var messageServiceMock = GetMock <IMessageService>();
var pending = !(ActionsRequiringPermissions.HandlePackageOwnershipRequest.CheckPermissions(currentUser, userToAdd) == PermissionsCheckResult.Allowed);
if (pending)
{
packageOwnershipManagementServiceMock
.Setup(p => p.AddPackageOwnershipRequestAsync(fakes.Package, currentUser, userToAdd))
.Returns(Task.FromResult(new PackageOwnerRequest {
ConfirmationCode = "confirmation-code"
}))
.Verifiable();
messageServiceMock
.Setup(m => m.SendPackageOwnerRequestAsync(
currentUser,
userToAdd,
fakes.Package,
TestUtility.GallerySiteRootHttps + "packages/FakePackage/",
TestUtility.GallerySiteRootHttps + $"packages/FakePackage/owners/{userToAdd.Username}/confirm/confirmation-code",
TestUtility.GallerySiteRootHttps + $"packages/FakePackage/owners/{userToAdd.Username}/reject/confirmation-code",
"Hello World! Html Encoded <3",
""))
.Returns(Task.CompletedTask)
.Verifiable();
foreach (var owner in fakes.Package.Owners)
{
messageServiceMock
.Setup(m => m.SendPackageOwnerRequestInitiatedNoticeAsync(
currentUser,
owner,
userToAdd,
fakes.Package,
It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Verifiable();
}
}
else
{
packageOwnershipManagementServiceMock
.Setup(p => p.AddPackageOwnerAsync(fakes.Package, userToAdd, true))
.Returns(Task.CompletedTask)
.Verifiable();
foreach (var owner in fakes.Package.Owners)
{
messageServiceMock
.Setup(m => m.SendPackageOwnerAddedNoticeAsync(
owner,
userToAdd,
fakes.Package,
It.IsAny <string>()))
.Returns(Task.CompletedTask)
.Verifiable();
}
}
JsonResult result = await controller.AddPackageOwner(fakes.Package.Id, userToAdd.Username, "Hello World! Html Encoded <3");
dynamic data = result.Data;
PackageOwnersResultViewModel model = data.model;
Assert.True(data.success);
Assert.Equal(userToAdd.Username, model.Name);
Assert.Equal(pending, model.Pending);
packageOwnershipManagementServiceMock.Verify();
messageServiceMock.Verify();
}
public Task BufferSong(CancellationToken cancelToken) =>
Task.Run(async () =>
{
Process p = null;
FileStream outStream = null;
try
{
p = Process.Start(new ProcessStartInfo
{
FileName = "ffmpeg",
Arguments = $"-ss {CurrentTrack.SkipTo} -i {CurrentTrack.SourceVideo.GetUri()} -f s16le -ar 48000 -vn -ac 2 pipe:1 -loglevel quiet",
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = false,
CreateNoWindow = true,
});
byte[] buffer = new byte[81920];
int currentFileSize = 0;
ulong prebufferSize = 100ul.MiB();
outStream = new FileStream(Basename + "-" + ++FileNumber, FileMode.Append, FileAccess.Write, FileShare.Read);
while (!p.HasExited) //Also fix low bandwidth
{
int bytesRead = await p.StandardOutput.BaseStream.ReadAsync(buffer, 0, buffer.Length, cancelToken).ConfigureAwait(false);
if (currentFileSize >= MaxFileSize)
{
try
{
outStream.Dispose();
}
catch { }
outStream = new FileStream(Basename + "-" + ++FileNumber, FileMode.Append, FileAccess.Write, FileShare.Read);
currentFileSize = bytesRead;
}
else
{
currentFileSize += bytesRead;
}
CurrentBufferSize += Convert.ToUInt64(bytesRead);
await outStream.WriteAsync(buffer, 0, bytesRead, cancelToken).ConfigureAwait(false);
while (CurrentBufferSize > prebufferSize)
await Task.Delay(100, cancelToken);
}
BufferingCompleted = true;
}
catch (Win32Exception ex)
{
Log.Message(LogSeverity.Error, ex.Message);
Log.Message(LogSeverity.Error, ex.StackTrace);
}
catch (Exception ex)
{
Log.Message(LogSeverity.Error, $"Buffering stopped: {ex.Message}");
}
finally
{
if (outStream != null)
outStream.Dispose();
Log.Message(LogSeverity.Debug, $"Buffering done.");
if (p != null)
{
try
{
p.Kill();
}
catch { }
p.Dispose();
}
}
});
static void Main()
{
Console.WriteLine("SIPSorcery Getting Started Video Call Demo");
Console.WriteLine("Press ctrl-c to exit.");
Log = AddConsoleLogger();
_sipTransport = new SIPTransport();
EnableTraceLogs(_sipTransport);
// Open a window to display the video feed from the remote SIP party.
_form = new Form();
_form.AutoSize = true;
_form.BackgroundImageLayout = ImageLayout.Center;
_picBox = new PictureBox
{
Size = new Size(640, 480),
Location = new Point(0, 0),
Visible = true
};
_form.Controls.Add(_picBox);
Application.EnableVisualStyles();
ThreadPool.QueueUserWorkItem(delegate { Application.Run(_form); });
ManualResetEvent formMre = new ManualResetEvent(false);
_form.Activated += (object sender, EventArgs e) => formMre.Set();
Console.WriteLine("Waiting for form activation.");
formMre.WaitOne();
_sipTransport.SIPTransportRequestReceived += OnSIPTransportRequestReceived;
string executableDir = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
var userAgent = new SIPUserAgent(_sipTransport, null);
var windowsAudioEndPoint = new WindowsAudioEndPoint(new AudioEncoder());
windowsAudioEndPoint.RestrictCodecs(new List <AudioCodecsEnum> {
AudioCodecsEnum.PCMU
});
var windowsVideoEndPoint = new WindowsVideoEndPoint();
MediaEndPoints mediaEndPoints = new MediaEndPoints
{
AudioSink = windowsAudioEndPoint,
AudioSource = windowsAudioEndPoint,
VideoSink = windowsVideoEndPoint,
VideoSource = windowsVideoEndPoint,
};
var voipMediaSession = new VoIPMediaSession(mediaEndPoints);
voipMediaSession.AcceptRtpFromAny = true;
// Place the call and wait for the result.
Task <bool> callTask = userAgent.Call(DESTINATION, null, null, voipMediaSession);
callTask.Wait(CALL_TIMEOUT_SECONDS * 1000);
ManualResetEvent exitMRE = new ManualResetEvent(false);
if (callTask.Result)
{
Log.LogInformation("Call attempt successful.");
windowsVideoEndPoint.OnVideoSinkDecodedSample += (byte[] bmp, uint width, uint height, int stride, VideoPixelFormatsEnum pixelFormat) =>
{
_picBox.BeginInvoke(new Action(() =>
{
unsafe
{
fixed(byte *s = bmp)
{
System.Drawing.Bitmap bmpImage = new System.Drawing.Bitmap((int)width, (int)height, stride, System.Drawing.Imaging.PixelFormat.Format24bppRgb, (IntPtr)s);
_picBox.Image = bmpImage;
}
}
}));
};
windowsAudioEndPoint.PauseAudio().Wait();
voipMediaSession.AudioExtrasSource.SetSource(AudioSourcesEnum.Music);
}
else
{
Log.LogWarning("Call attempt failed.");
Console.WriteLine("Press ctrl-c to exit.");
}
Console.CancelKeyPress += delegate(object sender, ConsoleCancelEventArgs e)
{
e.Cancel = true;
Log.LogInformation("Exiting...");
exitMRE.Set();
};
exitMRE.WaitOne();
if (userAgent.IsCallActive)
{
Log.LogInformation("Hanging up.");
userAgent.Hangup();
Task.Delay(1000).Wait();
}
// Clean up.
_form.BeginInvoke(new Action(() => _form.Close()));
_sipTransport.Shutdown();
}
protected RedirectToRouteResult RedirectToAction(Task<IActionResult> taskResult)
{
return RedirectToAction(taskResult.Result);
}
/// <summary>
/// This method is called when replica's state has been restored successfully via the Backup Restore service
/// </summary>
/// <param name="cancellationToken">
/// <see cref="CancellationToken"/> to monitor for cancellation requests.
/// </param>
/// <returns>
/// A Task that represents the asynchronous operation.
/// </returns>
protected virtual Task OnRestoreCompletedAsync(CancellationToken cancellationToken)
{
return Task.FromResult(0);
}
public async Task ShouldLogError_WhenSaveChangesThrows()
{
// Arrange
var context = Fixture.Freeze <Mock <IDbContext> >();
var token = new CancellationToken();
var exception = Fixture.Create <Exception>();
context.Setup(x => x.SaveChangesAsync(token)).Callback(() => throw exception);
var logger = Fixture.Freeze <Mock <ILogger <CustomCommand <int> > > >();
var sut = Fixture.Create <SaveChangesBehaviour <CustomCommand <int>, int> >();
// Act
Func <Task <int> > act = () => sut.Handle(new CustomCommand <int>(), token, () => Task.FromResult(0));
// Assert
await act.Should().ThrowExactlyAsync <Exception>();
logger.Verify(x => x.LogError("Error while saving changes", exception), Times.Once);
}
/// <summary>
/// This method is called when role of the replica is changing and it is the final step before completing <see cref="IStatefulServiceReplica.ChangeRoleAsync"/>.
/// Override this method to be notified that ChangeRole has completed for this replica's internal components.
/// <para>
/// For information about Reliable Services life cycle please see
/// https://docs.microsoft.com/azure/service-fabric/service-fabric-reliable-services-lifecycle
/// </para>
/// </summary>
/// <param name="newRole">New <see cref="ReplicaRole"/> for this service replica.</param>
/// <param name="cancellationToken">Cancellation token to monitor for cancellation requests.</param>
/// <returns>
/// A <see cref="Task"/> that represents outstanding operation.
/// </returns>
protected virtual Task OnChangeRoleAsync(ReplicaRole newRole, CancellationToken cancellationToken)
{
return Task.FromResult(true);
}
public async Task<List<ActionResult>> Validate(DeploymentTaskExecutionParams execParams)
{
var results = new List<ActionResult> { };
return await Task.FromResult(results);
}
/// <summary>
/// This method is called as the final step of closing the service gracefully.
/// Override this method to be notified that Close has completed for this replica's internal components.
/// <para>
/// For information about Reliable Services life cycle please see
/// https://docs.microsoft.com/azure/service-fabric/service-fabric-reliable-services-lifecycle
/// </para>
/// </summary>
/// <param name="cancellationToken">Cancellation token to monitor for cancellation requests.</param>
/// <returns>
/// A <see cref="System.Threading.Tasks.Task">Task</see> that represents outstanding operation.
/// </returns>
protected virtual Task OnCloseAsync(CancellationToken cancellationToken)
{
return Task.FromResult(true);
}
protected override Task SaveLocalToken(string token)
{
SetLocalValue(SettingsUserNameKey, token);
return(Task.FromResult(true));
}
/// <summary>
/// This method is called when the replica is being opened and it is the final step of opening the service.
/// Override this method to be notified that Open has completed for this replica's internal components.
/// <para>
/// For information about Reliable Services life cycle please see
/// https://docs.microsoft.com/azure/service-fabric/service-fabric-reliable-services-lifecycle
/// </para>
/// </summary>
/// <param name="openMode"><see cref="ReplicaOpenMode"/> for this service replica.</param>
/// <param name="cancellationToken">Cancellation token to monitor for cancellation requests.</param>
/// <returns>
/// A <see cref="Task">Task</see> that represents outstanding operation.
/// </returns>
protected virtual Task OnOpenAsync(ReplicaOpenMode openMode, CancellationToken cancellationToken)
{
return Task.FromResult(true);
}
public void ConfigureAuth(IAppBuilder app)
{
string ClientId = ConfigurationManager.AppSettings["ida:ClientID"];
string Password = ConfigurationManager.AppSettings["ida:Password"];
string Authority = string.Format(ConfigurationManager.AppSettings["ida:Authority"], "common");
string GraphAPIIdentifier = ConfigurationManager.AppSettings["ida:GraphAPIIdentifier"];
string AzureResourceManagerIdentifier = ConfigurationManager.AppSettings["ida:AzureResourceManagerIdentifier"];
app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
app.UseCookieAuthentication(new CookieAuthenticationOptions { });
app.UseOpenIdConnectAuthentication(
new OpenIdConnectAuthenticationOptions
{
ClientId = ClientId,
Authority = Authority,
TokenValidationParameters = new System.IdentityModel.Tokens.TokenValidationParameters
{
// we inject our own multitenant validation logic
ValidateIssuer = false,
},
Notifications = new OpenIdConnectAuthenticationNotifications()
{
RedirectToIdentityProvider = (context) =>
{
// This ensures that the address used for sign in and sign out is picked up dynamically from the request
// this allows you to deploy your app (to Azure Web Sites, for example) without having to change settings
// Remember that the base URL of the address used here must be provisioned in Azure AD beforehand.
//string appBaseUrl = context.Request.Scheme + "://" + context.Request.Host + context.Request.PathBase;
context.ProtocolMessage.RedirectUri = HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path);
context.ProtocolMessage.PostLogoutRedirectUri = new UrlHelper(HttpContext.Current.Request.RequestContext).Action
("Index", "Home", null, HttpContext.Current.Request.Url.Scheme);
context.ProtocolMessage.Resource = GraphAPIIdentifier;
return Task.FromResult(0);
},
AuthorizationCodeReceived = (context) =>
{
ClientCredential credential = new ClientCredential(ClientId, Password);
string tenantID = context.AuthenticationTicket.Identity.FindFirst("http://schemas.microsoft.com/identity/claims/tenantid").Value;
string signedInUserUniqueName = context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.Name).Value.Split('#')[context.AuthenticationTicket.Identity.FindFirst(ClaimTypes.Name).Value.Split('#').Length - 1];
AuthenticationContext authContext = new AuthenticationContext(string.Format("https://login.windows.net/{0}", tenantID),
new ADALTokenCache(signedInUserUniqueName));
//var items = authContext.TokenCache.ReadItems().ToList();
AuthenticationResult result1 = authContext.AcquireTokenByAuthorizationCode(
context.Code, new Uri(HttpContext.Current.Request.Url.GetLeftPart(UriPartial.Path)), credential);
//items = authContext.TokenCache.ReadItems().ToList();
AuthenticationResult result2 = authContext.AcquireTokenSilent(ConfigurationManager.AppSettings["ida:AzureResourceManagerIdentifier"], credential,
new UserIdentifier(signedInUserUniqueName, UserIdentifierType.RequiredDisplayableId));
//items = authContext.TokenCache.ReadItems().ToList();
return Task.FromResult(0);
},
// we use this notification for injecting our custom logic
SecurityTokenValidated = (context) =>
{
// retriever caller data from the incoming principal
string issuer = context.AuthenticationTicket.Identity.FindFirst("iss").Value;
if (!issuer.StartsWith("https://sts.windows.net/"))
// the caller is not from a trusted issuer - throw to block the authentication flow
throw new System.IdentityModel.Tokens.SecurityTokenValidationException();
return Task.FromResult(0);
},
//AuthenticationFailed = (context) =>
//{
// context.OwinContext.Response.Redirect(new UrlHelper(HttpContext.Current.Request.RequestContext).
// Action("Index", "Home", null, HttpContext.Current.Request.Url.Scheme));
// context.HandleResponse(); // Suppress the exception
// return Task.FromResult(0);
//}
}
});
}
public override Task <string> GetLastTokenAsync()
{
return(Task.FromResult(GetLocalValue(SettingsUserNameKey)));
}
public Task Handle(TrackZipCodeReply message, IMessageHandlerContext context)
{
Logger.Log($"##### CandidateVote saga for {Data.Candidate} got reply for zip code '{message.ZipCode}' tracking with current count of {message.CurrentCount}");
return Task.FromResult(0);
}
public AsyncLock()
{
this.semaphore = new SemaphoreSlim(1);
this.releaser = Task.FromResult(new Releaser(this));
}
private Task<string> serializeRequest<Rq>(Rq request) where Rq : class => Task.FromResult(request != null ? JsonSerializer.Serialize(request, options) : null);
private Task<Rs> deserializeResponse<Rs>(string responseMessage) where Rs : class
{
return Task.FromResult(responseMessage != null ? JsonSerializer.Deserialize<Rs>(responseMessage, options) : null);
}
private async Task Invoke(HubMethodDescriptor descriptor, HubConnectionContext connection,
HubMethodInvocationMessage hubMethodInvocationMessage, bool isStreamResponse, bool isStreamCall)
{
var methodExecutor = descriptor.MethodExecutor;
var disposeScope = true;
var scope = _serviceScopeFactory.CreateScope();
IHubActivator <THub> hubActivator = null;
THub hub = null;
try
{
if (!await IsHubMethodAuthorized(scope.ServiceProvider, connection.User, descriptor.Policies))
{
Log.HubMethodNotAuthorized(_logger, hubMethodInvocationMessage.Target);
await SendInvocationError(hubMethodInvocationMessage.InvocationId, connection,
$"Failed to invoke '{hubMethodInvocationMessage.Target}' because user is unauthorized");
return;
}
if (!await ValidateInvocationMode(descriptor, isStreamResponse, hubMethodInvocationMessage, connection))
{
return;
}
hubActivator = scope.ServiceProvider.GetRequiredService <IHubActivator <THub> >();
hub = hubActivator.Create();
if (isStreamCall)
{
// swap out placeholders for channels
var args = hubMethodInvocationMessage.Arguments;
for (int i = 0; i < args.Length; i++)
{
var placeholder = args[i] as StreamPlaceholder;
if (placeholder == null)
{
continue;
}
Log.StartingParameterStream(_logger, placeholder.StreamId);
var itemType = methodExecutor.MethodParameters[i].ParameterType.GetGenericArguments()[0];
args[i] = connection.StreamTracker.AddStream(placeholder.StreamId, itemType);
}
}
try
{
InitializeHub(hub, connection);
Task invocation = null;
CancellationTokenSource cts = null;
var arguments = hubMethodInvocationMessage.Arguments;
if (descriptor.HasSyntheticArguments)
{
// In order to add the synthetic arguments we need a new array because the invocation array is too small (it doesn't know about synthetic arguments)
arguments = new object[descriptor.OriginalParameterTypes.Count];
var hubInvocationArgumentPointer = 0;
for (var parameterPointer = 0; parameterPointer < arguments.Length; parameterPointer++)
{
if (hubMethodInvocationMessage.Arguments.Length > hubInvocationArgumentPointer &&
hubMethodInvocationMessage.Arguments[hubInvocationArgumentPointer].GetType() == descriptor.OriginalParameterTypes[parameterPointer])
{
// The types match so it isn't a synthetic argument, just copy it into the arguments array
arguments[parameterPointer] = hubMethodInvocationMessage.Arguments[hubInvocationArgumentPointer];
hubInvocationArgumentPointer++;
}
else
{
// This is the only synthetic argument type we currently support
if (descriptor.OriginalParameterTypes[parameterPointer] == typeof(CancellationToken))
{
cts = CancellationTokenSource.CreateLinkedTokenSource(connection.ConnectionAborted);
arguments[parameterPointer] = cts.Token;
}
else
{
// This should never happen
Debug.Assert(false, $"Failed to bind argument of type '{descriptor.OriginalParameterTypes[parameterPointer].Name}' for hub method '{methodExecutor.MethodInfo.Name}'.");
}
}
}
}
if (isStreamResponse)
{
var result = await ExecuteHubMethod(methodExecutor, hub, arguments);
if (!TryGetStreamingEnumerator(connection, hubMethodInvocationMessage.InvocationId, descriptor, result, out var enumerator, ref cts))
{
Log.InvalidReturnValueFromStreamingMethod(_logger, methodExecutor.MethodInfo.Name);
await SendInvocationError(hubMethodInvocationMessage.InvocationId, connection,
$"The value returned by the streaming method '{methodExecutor.MethodInfo.Name}' is not a ChannelReader<>.");
return;
}
Log.StreamingResult(_logger, hubMethodInvocationMessage.InvocationId, methodExecutor);
_ = StreamResultsAsync(hubMethodInvocationMessage.InvocationId, connection, enumerator, scope, hubActivator, hub, cts);
}
else if (string.IsNullOrEmpty(hubMethodInvocationMessage.InvocationId))
{
// Send Async, no response expected
invocation = ExecuteHubMethod(methodExecutor, hub, arguments);
}
else
{
// Invoke Async, one reponse expected
async Task ExecuteInvocation()
{
var result = await ExecuteHubMethod(methodExecutor, hub, arguments);
Log.SendingResult(_logger, hubMethodInvocationMessage.InvocationId, methodExecutor);
await connection.WriteAsync(CompletionMessage.WithResult(hubMethodInvocationMessage.InvocationId, result));
}
invocation = ExecuteInvocation();
}
if (isStreamCall || isStreamResponse)
{
// don't await streaming invocations
// leave them running in the background, allowing dispatcher to process other messages between streaming items
disposeScope = false;
}
else
{
// complete the non-streaming calls now
await invocation;
}
}
catch (TargetInvocationException ex)
{
Log.FailedInvokingHubMethod(_logger, hubMethodInvocationMessage.Target, ex);
await SendInvocationError(hubMethodInvocationMessage.InvocationId, connection,
ErrorMessageHelper.BuildErrorMessage($"An unexpected error occurred invoking '{hubMethodInvocationMessage.Target}' on the server.", ex.InnerException, _enableDetailedErrors));
}
catch (Exception ex)
{
Log.FailedInvokingHubMethod(_logger, hubMethodInvocationMessage.Target, ex);
await SendInvocationError(hubMethodInvocationMessage.InvocationId, connection,
ErrorMessageHelper.BuildErrorMessage($"An unexpected error occurred invoking '{hubMethodInvocationMessage.Target}' on the server.", ex, _enableDetailedErrors));
}
}
finally
{
if (disposeScope)
{
hubActivator?.Release(hub);
scope.Dispose();
}
}
}
public async Task <ActionResult> SparkSvgAll <T>(Func <Node, Task <List <T> > > getPoints, Func <Node, List <T>, long> getMax, Func <T, double> getVal) where T : IGraphPoint
{
const int width = SparkPoints;
var nodes = Dashboard.AllNodes;
var overallHeight = nodes.Count * SparkHeight;
long nowEpoch = DateTime.UtcNow.ToEpochTime(),
startEpoch = SparkStart.ToEpochTime();
var range = (nowEpoch - startEpoch) / (float)width;
var sb = StringBuilderCache.Get()
.AppendFormat("<svg version=\"1.1\" baseProfile=\"full\" width=\"{0}\" height=\"{1}\" xmlns=\"http://www.w3.org/2000/svg\" preserveAspectRatio=\"none\">\n", width.ToString(), overallHeight.ToString())
.AppendLine("\t<style>")
.AppendFormat("\t\tline {{ stroke:{0}; stroke-width:1 }}\n", AxisColor)
.AppendFormat("\t\tpath {{ fill:{0}; stroke:none; }}\n", Color)
.AppendLine("\t</style>");
var pointsLookup = new ConcurrentDictionary <string, List <T> >();
var maxLookup = new ConcurrentDictionary <string, long>();
var lookups = new List <Task>(nodes.Count);
foreach (var node in nodes)
{
lookups.Add(getPoints(node).ContinueWith(t =>
{
if (!t.IsFaulted)
{
pointsLookup[node.Id] = t.Result;
maxLookup[node.Id] = getMax(node, t.Result);
}
}));
}
await Task.WhenAll(lookups);
int currentYTop = 0;
foreach (var pl in pointsLookup)
{
sb.AppendFormat("\t<view id=\"{0}\" viewBox=\"0 {1} {2} {3}\" />\n", pl.Key, currentYTop, width, SparkHeight)
.AppendFormat("\t<g transform=\"translate(0, {0})\">\n", currentYTop)
.AppendFormat("\t\t<line x1=\"0\" y1=\"{0}\" x2=\"{1}\" y2=\"{0}\" />\n", SparkHeight.ToString(), width.ToString())
.AppendFormat("\t\t<path d=\"M0 {0} L", SparkHeight);
var first = true;
long divisor = maxLookup[pl.Key] / SparkHeight;
foreach (var p in pl.Value)
{
var pos = (p.DateEpoch - startEpoch) / range;
if (first && pos > 0)
{
// TODO: Indicate a missing, ungraphed time portion?
sb.Append((pos - 1).ToString("f1", CultureInfo.InvariantCulture))
.Append(" ")
.Append(SparkHeight)
.Append(" ");
first = false;
}
sb.Append(pos.ToString("f1", CultureInfo.InvariantCulture)).Append(" ")
.Append((SparkHeight - (getVal(p) / divisor)).ToString("f1", CultureInfo.InvariantCulture)).Append(" ");
}
sb.Append(width)
.Append(" ")
.Append(SparkHeight)
.Append(@" z""/>\n")
.Append("\t</g>\n");
currentYTop += SparkHeight;
}
sb.Append("</svg>");
var bytes = Encoding.UTF8.GetBytes(sb.ToStringRecycle());
return(new FileContentResult(bytes, "image/svg+xml"));
}
