public DataReturnUploadError(ErrorLevel errorLevel, UploadErrorType errorType, string description, int lineNumber = 0)
{
ErrorType = errorType;
ErrorLevel = errorLevel;
Description = description;
LineNumber = lineNumber;
}
public MemberUploadError(ErrorLevel errorLevel, UploadErrorType errorType, string description, int lineNumber = 0)
{
ErrorType = errorType;
ErrorLevel = errorLevel;
Description = description;
LineNumber = lineNumber;
}
internal static void CompleteSession(UploadSession session, UploadErrorType errorType)
{
bool hasErrored = (errorType != UploadErrorType.None);
int successfulFiles = 0;
if (!hasErrored)
{
foreach (UploadRequest request in session.UploadRequests)
{
if (session.CancelledRequests != null && Array.IndexOf<string>(session.CancelledRequests, request.UploadRequestId) != -1)
CancelRequest(request);
// TODO: we assume if it is uploading that it is almost done and do nothing. Instead, we should block until it becomes not uploading,
// or nuke it if it doesn't finish shortly
/*if (request.State == UploadState.Uploading)
throw new Exception("Request " + request.UploadRequestId + " is still processing.");
if (request.State == UploadState.Uploading)
CancelRequest(request);*/
// TODO: should we consider cancels as not errored? I guess not, because we still consider it an error if everything was cancelled. Maybe revisit when we do AllowPartialError
if (request.ErrorType != UploadErrorType.None)
hasErrored = true;
else
successfulFiles += request._uploadedFilesInternal.Count;
}
}
if (hasErrored && errorType == UploadErrorType.None && session.UploadProfile.AllowPartialError && successfulFiles > 0)
hasErrored = false;
if (hasErrored && errorType == UploadErrorType.None)
{
// Try to find an error
foreach (UploadRequest request in session.UploadRequests)
{
if (request.ErrorType != UploadErrorType.None)
{
errorType = request.ErrorType;
break;
}
}
if (errorType == UploadErrorType.None)
errorType = UploadErrorType.Other;
}
session.State = !hasErrored ? UploadState.Complete : UploadState.Error;
session.ErrorType = errorType;
UpdateSession(session);
// TODO: what happens here if a request is still in progress for some reason. Can we guarantee that never happens?
foreach (UploadRequest request in session.UploadRequests)
{
bool isFailedRequest = (session.FailedRequests != null && Array.IndexOf<string>(session.FailedRequests, request.UploadRequestId) != -1);
if (hasErrored || request.ErrorType != UploadErrorType.None || isFailedRequest)
{
if (isFailedRequest)
{
request.State = UploadState.Error;
if (request.ErrorType == UploadErrorType.None)
request.ErrorType = UploadErrorType.FailedByClient;
}
CleanupRequest(request);
}
}
}
/// <summary>
/// Sends workspace and its' dependencies to Flood.
/// </summary>
/// <returns>String which is response from server.</returns>
internal string Send(IEnumerable<IWorkspaceModel> workspaces)
{
if (String.IsNullOrWhiteSpace(serverUrl))
{
Error = UploadErrorType.ServerNotFound;
return Resource.FailedMessage;
}
if (String.IsNullOrWhiteSpace(authenticationProvider.Username))
{
Error = UploadErrorType.AuthenticationFailed;
return Resource.FailedMessage;
}
if (authenticationProvider == null)
{
Error = UploadErrorType.AuthProviderNotFound;
return Resource.FailedMessage;
}
string fullServerAdress = serverUrl + ":" + port;
if (reachClient == null)
reachClient = new WorkspaceStorageClient(authenticationProvider, fullServerAdress);
HomeWorkspace = workspaces.OfType<HomeWorkspaceModel>().First();
var functionNodes = HomeWorkspace.Nodes.OfType<Function>();
List<CustomNodeDefinition> dependencies = new List<CustomNodeDefinition>();
foreach (var node in functionNodes)
{
dependencies.AddRange(node.Definition.Dependencies);
}
CustomNodeWorkspaces = new List<ICustomNodeWorkspaceModel>();
foreach (var dependency in dependencies)
{
ICustomNodeWorkspaceModel customNodeWs;
var isWorkspaceCreated = customNodeManager.TryGetFunctionWorkspace(dependency.FunctionId, false, out customNodeWs);
if (isWorkspaceCreated && !CustomNodeWorkspaces.Contains(customNodeWs))
CustomNodeWorkspaces.Add(customNodeWs);
}
string result;
try
{
result = reachClient.Send(HomeWorkspace, CustomNodeWorkspaces.OfType<CustomNodeWorkspaceModel>());
}
catch
{
result = Resource.FailedMessage;
}
return result;
}
internal void SendAsynchronously(IEnumerable<IWorkspaceModel> workspaces)
{
State = UploadState.Uploading;
Task.Factory.StartNew(() =>
{
var result = this.Send(workspaces);
if (result == Resource.WorkspacesSendSucceededServerResponse)
{
State = UploadState.Succeeded;
Error = UploadErrorType.None;
}
else
{
// If there wasn't any error during uploading,
// that means it's some error on the server side.
Error = UploadErrorType.UnknownServerError;
}
});
}
internal void Authenticate()
{
// Manager must be initialized in constructor.
if (authenticationProvider == null)
{
Error = UploadErrorType.AuthProviderNotFound;
return;
}
var loggedIn = authenticationProvider.Login();
if (!loggedIn)
{
Error = UploadErrorType.AuthenticationFailed;
}
}
internal static void CompleteSession(UploadSession session, UploadErrorType errorType)
{
bool hasErrored = (errorType != UploadErrorType.None);
int successfulFiles = 0;
if (!hasErrored)
{
foreach (UploadRequest request in session.UploadRequests)
{
if (session.CancelledRequests != null && Array.IndexOf <string>(session.CancelledRequests, request.UploadRequestId) != -1)
{
CancelRequest(request);
}
// TODO: we assume if it is uploading that it is almost done and do nothing. Instead, we should block until it becomes not uploading,
// or nuke it if it doesn't finish shortly
/*if (request.State == UploadState.Uploading)
* throw new Exception("Request " + request.UploadRequestId + " is still processing.");
* if (request.State == UploadState.Uploading)
* CancelRequest(request);*/
// TODO: should we consider cancels as not errored? I guess not, because we still consider it an error if everything was cancelled. Maybe revisit when we do AllowPartialError
if (request.ErrorType != UploadErrorType.None)
{
hasErrored = true;
}
else
{
successfulFiles += request._uploadedFilesInternal.Count;
}
}
}
if (hasErrored && errorType == UploadErrorType.None && session.UploadProfile.AllowPartialError && successfulFiles > 0)
{
hasErrored = false;
}
if (hasErrored && errorType == UploadErrorType.None)
{
// Try to find an error
foreach (UploadRequest request in session.UploadRequests)
{
if (request.ErrorType != UploadErrorType.None)
{
errorType = request.ErrorType;
break;
}
}
if (errorType == UploadErrorType.None)
{
errorType = UploadErrorType.Other;
}
}
session.State = !hasErrored ? UploadState.Complete : UploadState.Error;
session.ErrorType = errorType;
UpdateSession(session);
// TODO: what happens here if a request is still in progress for some reason. Can we guarantee that never happens?
foreach (UploadRequest request in session.UploadRequests)
{
bool isFailedRequest = (session.FailedRequests != null && Array.IndexOf <string>(session.FailedRequests, request.UploadRequestId) != -1);
if (hasErrored || request.ErrorType != UploadErrorType.None || isFailedRequest)
{
if (isFailedRequest)
{
request.State = UploadState.Error;
if (request.ErrorType == UploadErrorType.None)
{
request.ErrorType = UploadErrorType.FailedByClient;
}
}
CleanupRequest(request);
}
}
}
