protected virtual WebProgressTask?PrepairProgressTask(HttpConnection connection)
{
var stream = connection.NetworkStream;
if (stream == null)
{
try
{
stream = connection.NetworkStream = connection.NetworkClient?.GetStream();
}
catch (InvalidOperationException)
{ return(null); }
}
var task = new WebProgressTask
{
CurrentStage = ServerStage.FIRST_STAGE,
NextStage = (ServerStage)((int)ServerStage.FIRST_STAGE + 1),
Server = this,
Connection = connection,
NetworkStream = stream,
};
if (Settings.MonitoringOutputDirectory != null)
{
task.EnableMonitoring();
}
return(task);
}
public override bool CanWorkWith(WebProgressTask task, out CallInfo?data)
{
if (!CheckPrecondition(task))
{
data = null;
return(false);
}
foreach (var service in Services)
{
using var watch = task.Monitor.Watch(service, "CanWorkWith()");
if (service is WebService2 service2)
{
if (service2.CanWorkWith(task, out object?data_))
{
data = new CallInfo(service, data_);
return(true);
}
}
else
{
if (service.CanWorkWith(task))
{
data = new CallInfo(service, null);
return(true);
}
}
GC.KeepAlive(watch);
}
data = null;
return(false);
}
public virtual void SetPost(WebProgressTask task, IO.ContentStream content, string?mime)
{
Content = content;
string args = "";
if (mime != null)
{
var ind = mime.IndexOf(';');
if (ind >= 0)
{
args = mime.Substring(ind + 1);
mime = mime.Remove(ind);
}
}
if ((MimeType = mime) != null &&
DataHandler.TryGetValue(mime !, out Func <IPostData>?constructor)
)
{
LazyData = new Lazy <Task <IPostData> >(() =>
{
return(Task.Run(async() =>
{
var data = constructor();
await data.SetAsync(task, content, args).ConfigureAwait(false);
return data;
}));
}, System.Threading.LazyThreadSafetyMode.ExecutionAndPublication);
}
public override Task ProgressTask(WebProgressTask task)
{
if (!task.Document.Information.TryGetValue(this, out object?data))
{
data = null;
}
return(ProgressTask(task, data));
}
public void SetPost(WebProgressTask task, ReadOnlyMemory <byte> post, string mime)
{
Task.Request.Post.SetPost(
task,
new IO.ContentStream(new IO.NetworkReader(new IO.SpanStream(post)), post.Length),
mime
);
}
public override Task ProgressTask(WebProgressTask task, CallInfo?data)
{
if (data is null)
{
return(Task.CompletedTask);
}
using (task.Monitor.Watch(data.Service, "ProgressTask()"))
return(data.ProgressTask(task));
}
public override bool CanWorkWith(WebProgressTask task)
{
if (!CanWorkWith(task, out object?data))
{
return(false);
}
task.Document[this] = data;
return(true);
}
public Task ProgressTask(WebProgressTask task)
{
if (Service is WebService2 ws2)
{
return(ws2.ProgressTask(task, Data));
}
else
{
return(Service.ProgressTask(task));
}
}
public WebServerTaskCreator()
{
Task = new WebProgressTask()
{
CurrentStage = ServerStage.FIRST_STAGE,
Connection = new HttpConnection
{
Ip = "127.0.0.1",
},
NetworkStream = new MemoryStream()
};
TerminationStage = ServerStage.FINAL_STAGE;
}
internal protected virtual async Task ExecuteTaskChain(WebProgressTask task, ServerStage terminationState = ServerStage.FINAL_STAGE)
{
if (task == null)
{
return;
}
while (true)
{
using var watch = task.Monitor.Watch(this, $"Web Service Group: {task.CurrentStage}");
await WebServiceGroups[task.CurrentStage].Execute(task).ConfigureAwait(false);
if (task.CurrentStage == terminationState)
{
break;
}
task.CurrentStage = task.NextStage;
task.NextStage = task.NextStage == ServerStage.FINAL_STAGE
? ServerStage.FINAL_STAGE
: (ServerStage)((int)task.NextStage + 1);
}
}
public abstract bool CanWorkWith(WebProgressTask task);
public abstract Task ProgressTask(WebProgressTask task);
/// <summary>
/// This is precondition that will be checked before all contained <see cref="WebService"
/// />s will be checked. This member is to be intended to be overwritten.
/// </summary>
/// <param name="task">The task that is currently executed.</param>
/// <returns>The check result.</returns>
public virtual bool CheckPrecondition(WebProgressTask task)
{
return(true);
}
public abstract bool CanWorkWith(WebProgressTask task, out object?data);
public abstract Task ProgressTask(WebProgressTask task, object?data);
