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); } } }