public override Task ExecuteBindingAsync(ModelMetadataProvider metadataProvider, HttpActionContext actionContext, CancellationToken cancellationToken)
{
// Caller should have already checked IsError before executing, so we shoulnd't be here.
return(TaskHelpers.FromError(new InvalidOperationException()));
}
public void ExecuteAuthorizationFilterAsync_IfContinuationTaskWasCanceled_ReturnsCanceledTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <AuthorizationFilterAttribute> filterMock = new Mock <AuthorizationFilterAttribute>();
var filter = (IAuthorizationFilter)filterMock.Object;
// Act
var result = filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => TaskHelpers.Canceled <HttpResponseMessage>());
// Assert
result.WaitUntilCompleted();
Assert.True(result.IsCanceled);
}
public void ExecuteAuthorizationFilterAsync_IfContinuationFaulted_ReturnsFaultedTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <AuthorizationFilterAttribute> filterMock = new Mock <AuthorizationFilterAttribute>();
var filter = (IAuthorizationFilter)filterMock.Object;
Exception exception = new Exception();
// Act
var result = filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromError <HttpResponseMessage>(exception));
// Assert
result.WaitUntilCompleted();
Assert.Same(exception, result.Exception.InnerException);
}
public async Task UnTriggered()
{
var e = new AutoResetEventAsync(false);
await TaskHelpers.AssertNotTriggered(e.WaitAsync());
}
public void ExecuteAsync_IsCancelled_And_Traces_When_Inner_IsCancelled()
{
// Arrange
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(TaskHelpers.Canceled <HttpResponseMessage>());
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Warn)
{
Kind = TraceKind.End
}
};
// Act
Task task = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None);
Exception thrown = Assert.Throws <TaskCanceledException>(() => task.Wait());
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
}
// TODO add cancelation token
static private async Task NewConnection(CancellationToken stop)
{
NHLog.Info("NHWebSocket", "STARTING nhmws SESSION");
try
{
// TODO think if we might want to dump prev data????
// on each new connection clear the ConcurrentQueues,
_recieveQueue = new ConcurrentQueue <MessageEventArgs>();
_sendQueue = new ConcurrentQueue <IEnumerable <NHSendMessage> >();
_isNhmwsRestart = false;
_notifyMinerStatusAfter.Value = null;
NHLog.Info("NHWebSocket", "Creating socket");
using (_webSocket = new WebSocket(_address))
{
_webSocket.SslConfiguration.EnabledSslProtocols = System.Security.Authentication.SslProtocols.Tls12;
//stop.Register(() => _webSocket.Close(CloseStatusCode.Normal, "Closing CancellationToken"));
_webSocket.OnOpen += Login;
_webSocket.OnMessage += (s, eMsg) => _recieveQueue.Enqueue(eMsg);
_webSocket.OnError += (s, e) => NHLog.Info("NHWebSocket", $"Error occured: {e.Message}");
_webSocket.OnClose += (s, e) => NHLog.Info("NHWebSocket", $"Connection closed code {e.Code}: {e.Reason}");;
_webSocket.Log.Level = LogLevel.Debug;
_webSocket.Log.Output = (data, s) => NHLog.Info("NHWebSocket", data.ToString());
_webSocket.EnableRedirection = true;
NHLog.Info("NHWebSocket", "Connecting");
_webSocket.Connect();
const int minerStatusTickSeconds = 45;
var checkWaitTime = TimeSpan.FromMilliseconds(50);
var skipMinerStatus = !CredentialValidators.ValidateBitcoinAddress(_login.btc);
NHLog.Info("NHWebSocket", "Starting Loop");
while (IsWsAlive && !stop.IsCancellationRequested)
{
if (IsWsAlive)
{
HandleSendMessage();
}
if (IsWsAlive)
{
await HandleReceiveMessage();
}
// TODO add here the last miner status send check
if (IsWsAlive)
{
await TaskHelpers.TryDelay(checkWaitTime, stop);
}
if (skipMinerStatus)
{
continue;
}
var elapsedTime = DateTime.UtcNow - _lastSendMinerStatusTimestamp.Value;
if (elapsedTime.TotalSeconds > minerStatusTickSeconds)
{
var minerStatusJsonStr = CreateMinerStatusMessage();
var minerStatus = new NHSendMessage(MessageType.SEND_MESSAGE_STATUS, minerStatusJsonStr);
_sendQueue.Enqueue(new NHSendMessage[1] {
minerStatus
});
}
if (_notifyMinerStatusAfter.Value.HasValue && DateTime.UtcNow >= _notifyMinerStatusAfter.Value.Value)
{
_notifyMinerStatusAfter.Value = null;
var minerStatusJsonStr = CreateMinerStatusMessage();
var minerStatus = new NHSendMessage(MessageType.SEND_MESSAGE_STATUS, minerStatusJsonStr);
_sendQueue.Enqueue(new NHSendMessage[1] {
minerStatus
});
}
}
// Ws closed
NHLog.Info("NHWebSocket", "Exited Loop");
}
}
catch (TaskCanceledException e)
{
NHLog.Debug("NHWebSocket", $"TaskCanceledException {e.Message}");
}
finally
{
NHLog.Info("NHWebSocket", "ENDING nhmws SESSION");
ApplicationStateManager.SetNhmwsConnectionChanged(false);
}
}
public async Task Triggered()
{
var e = new AutoResetEventAsync(true);
await TaskHelpers.AssertTriggered(e.WaitAsync());
}
private void SetupUpRoundTripSerialization(Func <Type, object> factory = null)
{
factory = factory ?? Activator.CreateInstance;
_formatterMock.Setup(f => f.WriteToStreamAsync(It.IsAny <Type>(), It.IsAny <object>(), It.IsAny <Stream>(), It.IsAny <HttpContent>(), It.IsAny <TransportContext>()))
.Returns(TaskHelpers.Completed());
_formatterMock.Setup(f => f.ReadFromStreamAsync(It.IsAny <Type>(), It.IsAny <Stream>(), It.IsAny <HttpContent>(), It.IsAny <IFormatterLogger>()))
.Returns <Type, Stream, HttpContent, IFormatterLogger>((type, stream, content, logger) => TaskHelpers.FromResult <object>(factory(type)));
}
public override Task Overridden_WriteToStreamAsyncWithoutCancellationToken_GetsCalled()
{
// WriteToStreamAsync is not overridable on BufferedMediaTypeFormatter.
// So, let this test be a NOOP
return(TaskHelpers.Completed());
}
public Task WrappedTaskReturningMethod()
{
return(TaskHelpers.FromResult(TaskHelpers.Completed()));
}
public object TaskAsObjectReturningMethod()
{
return(TaskHelpers.Completed());
}
public Task DeleteAllUsersAsync()
{
return(TaskHelpers.Completed());
}
public When_a_consumer_has_multiple_handlers()
{
mockBuilder = new MockBuilder();
var queue = new Queue("test_queue", false, false, false, false);
var countdownEvent = new CountdownEvent(3);
mockBuilder.Bus.Advanced.Consume(queue, x => x
.Add <MyMessage>((message, info) => TaskHelpers.ExecuteSynchronously(() =>
{
myMessageResult = message.Body;
countdownEvent.Signal();
}))
.Add <MyOtherMessage>((message, info) => TaskHelpers.ExecuteSynchronously(() =>
{
myOtherMessageResult = message.Body;
countdownEvent.Signal();
}))
.Add <IAnimal>((message, info) => TaskHelpers.ExecuteSynchronously(() =>
{
animalResult = message.Body;
countdownEvent.Signal();
})));
Deliver(new MyMessage {
Text = "Hello Polymorphs!"
});
Deliver(new MyOtherMessage {
Text = "Hello Isomorphs!"
});
Deliver(new Dog());
countdownEvent.Wait(1000);
}
/// <summary>
/// Called during deserialization to read an object of the specified <paramref name="type"/>
/// from the specified <paramref name="readStream"/>.
/// </summary>
/// <param name="type">The type of object to read.</param>
/// <param name="readStream">The <see cref="Stream"/> from which to read.</param>
/// <param name="content">The <see cref="HttpContent"/> for the content being written.</param>
/// <param name="formatterLogger">The <see cref="IFormatterLogger"/> to log events to.</param>
/// <returns>A <see cref="Task"/> whose result will be the object instance that has been read.</returns>
public override Task <object> ReadFromStreamAsync(Type type, Stream readStream, HttpContent content, IFormatterLogger formatterLogger)
{
if (type == null)
{
throw Error.ArgumentNull("type");
}
if (readStream == null)
{
throw Error.ArgumentNull("readStream");
}
return(TaskHelpers.RunSynchronously <object>(() =>
{
HttpContentHeaders contentHeaders = content == null ? null : content.Headers;
// If content length is 0 then return default value for this type
if (contentHeaders != null && contentHeaders.ContentLength == 0)
{
return GetDefaultValueForType(type);
}
// Get the character encoding for the content
Encoding effectiveEncoding = SelectCharacterEncoding(contentHeaders);
try
{
#if !NETFX_CORE // No DataContractJsonSerializer in portable library version
if (UseDataContractJsonSerializer)
{
DataContractJsonSerializer dataContractSerializer = GetDataContractSerializer(type);
using (XmlReader reader = JsonReaderWriterFactory.CreateJsonReader(new NonClosingDelegatingStream(readStream), effectiveEncoding, _readerQuotas, null))
{
return dataContractSerializer.ReadObject(reader);
}
}
else
#endif
{
using (JsonTextReader jsonTextReader = new JsonTextReader(new StreamReader(readStream, effectiveEncoding))
{
CloseInput = false, MaxDepth = _maxDepth
})
{
JsonSerializer jsonSerializer = JsonSerializer.Create(_jsonSerializerSettings);
if (formatterLogger != null)
{
// Error must always be marked as handled
// Failure to do so can cause the exception to be rethrown at every recursive level and overflow the stack for x64 CLR processes
jsonSerializer.Error += (sender, e) =>
{
Exception exception = e.ErrorContext.Error;
formatterLogger.LogError(e.ErrorContext.Path, exception);
e.ErrorContext.Handled = true;
};
}
return jsonSerializer.Deserialize(jsonTextReader, type);
}
}
}
catch (Exception e)
{
if (formatterLogger == null)
{
throw;
}
formatterLogger.LogError(String.Empty, e);
return GetDefaultValueForType(type);
}
}));
}
public static AppFunc Middleware(AppFunc app)
{
return(env =>
{
Action <Exception, Action <byte[], int, int> > showErrorMessage =
(ex, write) =>
ErrorPage(env, ex, text =>
{
var data = Encoding.ASCII.GetBytes(text);
write(data, 0, data.Length);
});
var response = new Response(env);
Func <Exception, Task> showErrorPage = ex =>
{
response.Status = "500 Internal Server Error";
response.ContentType = "text/html";
showErrorMessage(ex, response.Write);
return TaskHelpers.Completed();
};
// Don't try to modify the headers after the first write has occurred.
TriggerStream triggerStream = new TriggerStream(response.Body);
response.Body = triggerStream;
bool bodyHasStarted = false;
triggerStream.OnFirstWrite = () =>
{
bodyHasStarted = true;
};
try
{
return app(env)
.Catch(errorInfo =>
{
if (!bodyHasStarted)
{
showErrorPage(errorInfo.Exception).Wait();
}
else
{
showErrorMessage(errorInfo.Exception, triggerStream.Write);
}
return errorInfo.Handled();
});
}
catch (Exception exception)
{
if (!bodyHasStarted)
{
return showErrorPage(exception);
}
else
{
showErrorMessage(exception, triggerStream.Write);
return TaskHelpers.Completed();
}
}
});
}
public virtual Task WriteMessageAsync(Message message, Stream stream)
{
WriteMessage(message, stream);
return(TaskHelpers.CompletedTask());
}
private async Task RunMinerWatchDogLoop(TaskCompletionSource <object> tsc, CancellationToken stop, string miningLocation, string username)
{
// if we fail 3 times in a row under certain conditions mark on of them
const int maxRestartCount = 3;
int restartCount = 0;
const int minRestartTimeInSeconds = 15;
try
{
var firstStart = true;
using (_endMiner = new CancellationTokenSource())
using (var linkedEndMiner = CancellationTokenSource.CreateLinkedTokenSource(stop, _endMiner.Token))
{
Logger.Info(MinerTag(), $"Starting miner watchdog task");
while (!linkedEndMiner.IsCancellationRequested && (restartCount < maxRestartCount))
{
var startTime = DateTime.UtcNow;
try
{
if (!firstStart)
{
Logger.Info(MinerTag(), $"Restart Mining in {MiningSettings.Instance.MinerRestartDelayMS}ms");
}
await TaskHelpers.TryDelay(MiningSettings.Instance.MinerRestartDelayMS, linkedEndMiner.Token);
var result = await StartAsync(linkedEndMiner.Token, miningLocation, username);
if (firstStart)
{
firstStart = false;
tsc.SetResult(result);
}
if (result is bool ok && ok)
{
var runningMinerTask = _miner.MinerProcessTask;
_ = MinerStatsLoop(runningMinerTask, linkedEndMiner.Token);
await runningMinerTask;
// TODO log something here
Logger.Info(MinerTag(), $"Running Miner Task Completed");
}
else
{
// TODO check if the miner file is missing or locked and blacklist the algorithm for a certain period of time
Logger.Error(MinerTag(), $"StartAsync result: {result}");
}
}
catch (TaskCanceledException e)
{
Logger.Debug(MinerTag(), $"RunMinerWatchDogLoop TaskCanceledException: {e.Message}");
return;
}
catch (Exception e)
{
Logger.Error(MinerTag(), $"RunMinerWatchDogLoop Exception: {e.Message}");
}
finally
{
var endTime = DateTime.UtcNow;
var elapsedSeconds = (endTime - startTime).TotalSeconds - (MiningSettings.Instance.MinerRestartDelayMS);
if (elapsedSeconds < minRestartTimeInSeconds)
{
restartCount++;
}
else
{
restartCount = 0;
}
if (restartCount >= maxRestartCount)
{
var firstAlgo = _algos.FirstOrDefault();
Random randWait = new Random();
firstAlgo.IgnoreUntil = DateTime.UtcNow.AddMinutes(randWait.Next(20, 30));
await MiningManager.MinerRestartLoopNotify();
}
}
}
public SharedAsyncConditionInverseValidator()
{
UnlessAsync(x => TaskHelpers.FromResult(x.Id == 0), () => { RuleFor(x => x.Forename).NotNull(); });
}
public async Task Cancellable()
{
var e = new AutoResetEventAsync(false);
var src = new CancellationTokenSource();
await TaskHelpers.AssertNotTriggered(e.WaitAsync(src.Token));
}
public void Executes_customasync_rule_when_async_condition_true()
{
var validator = new TestValidator();
validator.WhenAsync(x => TaskHelpers.FromResult(true), () => validator.CustomAsync(x => TaskHelpers.FromResult(new ValidationFailure("foo", "bar"))));
var result = validator.ValidateAsync(new Person()).Result;
result.IsValid.ShouldBeFalse();
}
public async Task Uncancellable()
{
var e = new AutoResetEventAsync(false);
await TaskHelpers.AssertNotTriggered(e.WaitAsync(CancellationToken.None));
}
private async Task <Message> RequestAsyncInternal(Message message, TimeSpan timeout)
{
await TaskHelpers.EnsureDefaultTaskScheduler();
return(await RequestAsync(message, timeout));
}
public void ExecuteAsync_Invokes_Inner_And_Traces()
{
// Arrange
HttpResponseMessage response = new HttpResponseMessage();
Mock <ApiController> mockController = new Mock <ApiController>()
{
CallBase = true
};
mockController.Setup(b => b.ExecuteAsync(It.IsAny <HttpControllerContext>(), It.IsAny <CancellationToken>())).Returns(TaskHelpers.FromResult <HttpResponseMessage>(response));
HttpRequestMessage request = new HttpRequestMessage();
HttpControllerContext controllerContext = ContextUtil.CreateControllerContext(request: request);
controllerContext.ControllerDescriptor = _controllerDescriptor;
controllerContext.Controller = mockController.Object;
HttpActionContext actionContext = ContextUtil.CreateActionContext(controllerContext, actionDescriptor: _mockActionDescriptor.Object);
TestTraceWriter traceWriter = new TestTraceWriter();
HttpControllerTracer tracer = new HttpControllerTracer(request, mockController.Object, traceWriter);
TraceRecord[] expectedTraces = new TraceRecord[]
{
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.Begin
},
new TraceRecord(actionContext.Request, TraceCategories.ControllersCategory, TraceLevel.Info)
{
Kind = TraceKind.End
}
};
// Act
HttpResponseMessage actualResponse = ((IHttpController)tracer).ExecuteAsync(controllerContext, CancellationToken.None).Result;
// Assert
Assert.Equal <TraceRecord>(expectedTraces, traceWriter.Traces, new TraceRecordComparer());
Assert.Same(response, actualResponse);
}
public void Async_condition_should_work_with_child_collection()
{
var validator = new TestValidator()
{
v => v.RuleFor(x => x.Orders).SetCollectionValidator(y => new OrderValidator(y)).WhenAsync(x => TaskHelpers.FromResult(x.Orders.Count == 4 /*there are only 3*/))
};
var result = validator.ValidateAsync(person).Result;
result.IsValid.ShouldBeTrue();
}
protected internal override Task OnOpenAsync(TimeSpan timeout)
{
this.OnOpen(timeout);
return(TaskHelpers.CompletedTask());
}
private Func <string, CancellationToken, Task <bool> > BeOneOfTheChildrensEmailAddress(Person person)
{
return((productName, cancel) => TaskHelpers.FromResult(person.Children.Any(child => child.Email == productName)));
}
public void ExecuteAuthorizationFilterAsync_IfContinuationSucceeded_ReturnsSuccessTask()
{
// Arrange
HttpActionContext context = ContextUtil.CreateActionContext();
Mock <AuthorizationFilterAttribute> filterMock = new Mock <AuthorizationFilterAttribute>();
var filter = (IAuthorizationFilter)filterMock.Object;
HttpResponseMessage response = new HttpResponseMessage();
// Act
var result = filter.ExecuteAuthorizationFilterAsync(context, CancellationToken.None, () => TaskHelpers.FromResult(response));
// Assert
result.WaitUntilCompleted();
Assert.Same(response, result.Result);
}
/// <summary>
/// Performs asynchronous validation using a validation context and returns a collection of Validation Failures.
/// </summary>
/// <param name="context">Validation Context</param>
/// <param name="cancellation"></param>
/// <returns>A collection of validation failures</returns>
public Task <IEnumerable <ValidationFailure> > ValidateAsync(ValidationContext context, CancellationToken cancellation)
{
try {
var displayName = GetDisplayName();
if (PropertyName == null && displayName == null)
{
//No name has been specified. Assume this is a model-level rule, so we should use empty string instead.
displayName = string.Empty;
}
// Construct the full name of the property, taking into account overriden property names and the chain (if we're in a nested validator)
var propertyName = context.PropertyChain.BuildPropertyName(PropertyName ?? displayName);
// Ensure that this rule is allowed to run.
// The validatselector has the opportunity to veto this before any of the validators execute.
if (!context.Selector.CanExecute(this, propertyName, context))
{
return(TaskHelpers.FromResult(Enumerable.Empty <ValidationFailure>()));
}
var cascade = cascadeModeThunk();
var failures = new List <ValidationFailure>();
var fastExit = false;
// Firstly, invoke all syncronous validators and collect their results.
foreach (var validator in validators.Where(v => !v.IsAsync))
{
if (cancellation.IsCancellationRequested)
{
return(TaskHelpers.Canceled <IEnumerable <ValidationFailure> >());
}
var results = InvokePropertyValidator(context, validator, propertyName);
failures.AddRange(results);
// If there has been at least one failure, and our CascadeMode has been set to StopOnFirst
// then don't continue to the next rule
if (fastExit = (cascade == CascadeMode.StopOnFirstFailure && failures.Count > 0))
{
break;
}
}
//if StopOnFirstFailure triggered then we exit
if (fastExit && failures.Count > 0)
{
// Callback if there has been at least one property validator failed.
OnFailure(context.InstanceToValidate);
return(TaskHelpers.FromResult(failures.AsEnumerable()));
}
var asyncValidators = validators.Where(v => v.IsAsync).ToList();
// if there's no async validators then we exit
if (asyncValidators.Count == 0)
{
if (failures.Count > 0)
{
// Callback if there has been at least one property validator failed.
OnFailure(context.InstanceToValidate);
}
else
{
RunDependentRulesAsync(failures, context, cancellation);
}
return(TaskHelpers.FromResult(failures.AsEnumerable()));
}
//Then call asyncronous validators in non-blocking way
var validations =
asyncValidators
// .Select(v => v.ValidateAsync(new PropertyValidatorContext(context, this, propertyName), cancellation)
.Select(v => InvokePropertyValidatorAsync(context, v, propertyName, cancellation)
//this is thread safe because tasks are launched sequencially
.Then(fs => failures.AddRange(fs), runSynchronously: true)
);
return
(TaskHelpers.Iterate(
validations,
breakCondition: _ => cascade == CascadeMode.StopOnFirstFailure && failures.Count > 0,
cancellationToken: cancellation
).Then(() => {
if (failures.Count > 0)
{
OnFailure(context.InstanceToValidate);
}
else
{
RunDependentRulesAsync(failures, context, cancellation);
}
return failures.AsEnumerable();
},
runSynchronously: true
));
}
catch (Exception ex) {
return(TaskHelpers.FromError <IEnumerable <ValidationFailure> >(ex));
}
}
Task IView.RenderAsync(ViewContext viewContext, TextWriter writer)
{
((IView)this).Render(viewContext, writer);
return(TaskHelpers.Completed());
}
Task NewServerCallback(IDictionary <string, object> env)
{
var path = (string)env[OwinConstants.RequestPath];
Tracing.Info(path);
if (!content.IsAvailable(path))
{
var path404 = "/404.html";
var use404 = content.IsAvailable(path404);
var response = new Response(env)
{
ContentType = use404 ? path404.MimeType() : path.MimeType()
};
using (var writer = new StreamWriter(response.OutputStream))
{
if (use404)
{
writer.Write(content.GetContent(path404));
}
else
{
writer.Write("Page not found: " + path);
}
}
return(TaskHelpers.Completed());
}
if (path.MimeType().IsBinaryMime())
{
var fileContents = content.GetBinaryContent(path);
var response = new Response(env)
{
ContentType = path.MimeType()
};
response.Headers["Content-Range"] = new[] { string.Format("bytes 0-{0}", (fileContents.Length - 1)) };
response.Headers["Content-Length"] = new[] { fileContents.Length.ToString(CultureInfo.InvariantCulture) };
response.Write(new ArraySegment <byte>(fileContents));
}
else if (content.IsDirectory(path) && !path.EndsWith("/"))
{
//if path is a directory without trailing slash, redirects to the same url with a trailing slash
var response = new Response(env)
{
Status = "301 Moved Permanently"
};
response.Headers["Location"] = new[] { String.Format("http://localhost:{0}{1}/", Port, path) };
}
else
{
var response = new Response(env)
{
ContentType = path.MimeType()
};
using (var writer = new StreamWriter(response.OutputStream))
{
writer.Write(content.GetContent(path));
}
}
return(TaskHelpers.Completed());
}
