private void PreCleanup() { SelectedDBService.DeleteItem( TableName, Key, new BPrimitiveType("test_1"), out JObject Ignore, EBReturnItemBehaviour.DoNotReturn, null); }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { //GET is supported for easy calls from terraform scripts since it only has GET request support out of the box. //https://www.terraform.io/docs/providers/http/data_source.html //POST calls are recommended to use over GET. if (_Context.Request.HttpMethod != "DELETE") { _ErrorMessageAction?.Invoke("ScheduleRequest: DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod)); } JObject ParsedBody = null; if (_Context.Request.HttpMethod == "DELETE") { using (var InputStream = _Context.Request.InputStream) { using (var ResponseReader = new StreamReader(InputStream)) { try { ParsedBody = JObject.Parse(ResponseReader.ReadToEnd()); } catch (Exception e) { _ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } } if (!ParsedBody.ContainsKey(ScheduledUrlTaskDBEntry.URL_PROPERTY) || ParsedBody[ScheduledUrlTaskDBEntry.URL_PROPERTY].Type != JTokenType.String) { return(BWebResponse.BadRequest("Request must contain all necessary fields validly. Given argument: " + ParsedBody.ToString())); } string Url = (string)ParsedBody[ScheduledUrlTaskDBEntry.URL_PROPERTY]; if (!Uri.TryCreate(Url, UriKind.Absolute, out Uri UriResult) || (UriResult.Scheme != Uri.UriSchemeHttp && UriResult.Scheme != Uri.UriSchemeHttps)) { return(BWebResponse.BadRequest("Given field " + ScheduledUrlTaskDBEntry.URL_PROPERTY + " is invalid. Given argument: " + ParsedBody.ToString())); } if (!DatabaseService.DeleteItem( ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(), ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL, new BPrimitiveType(WebUtility.UrlEncode(Url)), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction)) { return(BWebResponse.InternalError("Database delete operation has failed.")); } return(BWebResponse.StatusOK("Task has been unscheduled.")); }
private void DB_DeleteItem_FireAndForget_Internal( string _Table, string _KeyName, BPrimitiveType _KeyValue, int _Current_RetryCount = 0, Action <string> _ErrorMessageAction = null) { if (DatabaseService == null) { return; } if (!DatabaseService.DeleteItem(_Table, _KeyName, _KeyValue, out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction)) { BroadcastFailed_FireAndForget_Operation(new Action_DeliveryEnsurer_DB_DeleteItem() { QueryType = Action_DeliveryEnsurer.QUERY_TYPE_DB_DELETE_ITEM, TableName = _Table, KeyName = _KeyName, KeyValue = new BPrimitiveType_JStringified(_KeyValue), RetryCount = _Current_RetryCount }, _ErrorMessageAction); } }
private void SecondCheck(HttpListenerContext _Context, List <ScheduledUrlTaskDBEntry> _URLTasks, Action <string> _ErrorMessageAction) { var WaitUntil = new ManualResetEvent(false); var Counter = new ConcurrentStack <bool>(); var DeleteItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>(); var FailedItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>(); var UpdateItems = new ConcurrentQueue <ScheduledUrlTaskDBEntry>(); var TimeHasComeFor = new List <ScheduledUrlTaskDBEntry>(); foreach (var URLTask in _URLTasks) { if (URLTask.ScheduledToTime < new DateTimeOffset(DateTime.UtcNow).ToUnixTimeSeconds()) { TimeHasComeFor.Add(URLTask); Counter.Push(true); } } foreach (var Current in TimeHasComeFor) { var Process = Current; BTaskWrapper.Run(() => { var bRequestSuccess = PerformHttpRequest(out int StatusCode, Process.Url, Process.Verb, Process.Headers, Process.Body, _ErrorMessageAction); bool bDeleted = false; foreach (int CancelReturnCode in Process.CancelOnReturnCodes) { if (CancelReturnCode == StatusCode) { bDeleted = true; DeleteItems.Enqueue(Process); break; } } if (!bDeleted) { if (bRequestSuccess) { if (Process.bCancelRetryOnSuccess) { DeleteItems.Enqueue(Process); } else { if (Process.RetryCount == -1 || (Process.RetriedCount + 1) <= Process.RetryCount) { UpdateItems.Enqueue(Process); } else { DeleteItems.Enqueue(Process); } } } else { FailedItems.Enqueue(Process); } } Counter.TryPop(out bool _); if (Counter.IsEmpty) { try { WaitUntil.Set(); } catch (Exception) { } } }); } try { if (TimeHasComeFor.Count > 0) { WaitUntil.WaitOne(); } WaitUntil.Close(); } catch (Exception) { } while (FailedItems.TryDequeue(out ScheduledUrlTaskDBEntry Failed)) { if (Failed.RetryCount == -1 || (Failed.RetriedCount + 1) <= Failed.RetryCount) { Failed.RetriedCount++; Failed.ScheduledToTime = new DateTimeOffset(DateTime.UtcNow.AddSeconds(Failed.RetryInSeconds)).ToUnixTimeSeconds(); DatabaseService.UpdateItem( ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(), ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL, new BPrimitiveType(WebUtility.UrlEncode(Failed.Url)), JObject.Parse(JsonConvert.SerializeObject(Failed)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction); } else { DeleteItems.Enqueue(Failed); } } while (UpdateItems.TryDequeue(out ScheduledUrlTaskDBEntry Update)) { Update.RetriedCount++; Update.ScheduledToTime = new DateTimeOffset(DateTime.UtcNow.AddSeconds(Update.RetryInSeconds)).ToUnixTimeSeconds(); DatabaseService.UpdateItem( ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(), ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL, new BPrimitiveType(WebUtility.UrlEncode(Update.Url)), JObject.Parse(JsonConvert.SerializeObject(Update)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction); } while (DeleteItems.TryDequeue(out ScheduledUrlTaskDBEntry Delete)) { DatabaseService.DeleteItem( ScheduledUrlTaskDBEntry.DBSERVICE_SCHEDULED_URL_TASKS_TABLE(), ScheduledUrlTaskDBEntry.KEY_NAME_TASK_URL, new BPrimitiveType(WebUtility.UrlEncode(Delete.Url)), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction); } }
private void Cleanup_UniqueFileFields(Action <string> _ErrorMessageAction) { if (!DatabaseService.ScanTable( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), out List <JObject> UniqueFieldsEntries, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("Cleanup_UniqueFileFields: Table does not exist or ScanTable operation has failed."); return; } if (UniqueFieldsEntries.Count == 0) { return; } foreach (var Current in UniqueFieldsEntries) { if (!Current.ContainsKey(ModelDBEntry.KEY_NAME_MODEL_ID)) { continue; } if (!Current.ContainsKey(UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME)) { continue; } var ModelUniqueName = (string)Current[UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME]; var ModelID = (string)Current[ModelDBEntry.KEY_NAME_MODEL_ID]; var Casted = JsonConvert.DeserializeObject <UniqueFileFieldsDBEntry>(Current.ToString()); try { if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction)) { continue; } bool bDeleteEntry = false; if (!DatabaseService.GetItem( ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelDBEntry.KEY_NAME_MODEL_ID, new BPrimitiveType(ModelID), ModelDBEntry.Properties, out JObject ModelObject, _ErrorMessageAction)) { continue; } if (ModelObject == null) { //Model does not exist bDeleteEntry = true; } else { var Model = JsonConvert.DeserializeObject <ModelDBEntry>(ModelObject.ToString()); bDeleteEntry = ModelUniqueName != Model.ModelName; } if (bDeleteEntry) { DatabaseService.DeleteItem( UniqueFileFieldsDBEntry.DBSERVICE_UNIQUEFILEFIELDS_TABLE(), UniqueFileFieldsDBEntry.KEY_NAME_MODEL_UNIQUE_NAME, new BPrimitiveType(ModelUniqueName), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction); } } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, ModelDBEntry.DBSERVICE_MODELS_TABLE(), ModelID, _ErrorMessageAction); } } }
private BWebServiceResponse UpdateUserInfo_Internal( HttpListenerContext _Context, string _NewEmailChange, string _NewUserNameChange, JObject _UserObject, JObject _UpdateFieldsUserEntry, JObject _UpdateFieldsAuthEntry, Action <string> _ErrorMessageAction) { var UserKey = new BPrimitiveType(RequestedUserID); if (_UpdateFieldsUserEntry.Count > 0) { string OldEmail = null; string OldUserName = null; if (_NewEmailChange != null && _UserObject.ContainsKey(UserDBEntry.USER_EMAIL_PROPERTY)) { OldEmail = (string)_UserObject[UserDBEntry.USER_EMAIL_PROPERTY]; Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(OldEmail)); Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_EMAIL, new BPrimitiveType(_NewEmailChange), new JObject() { [UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID }); } if (_NewUserNameChange != null && _UserObject.ContainsKey(UserDBEntry.USER_NAME_PROPERTY)) { OldUserName = (string)_UserObject[UserDBEntry.USER_NAME_PROPERTY]; Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME, new BPrimitiveType(OldUserName)); Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_USER_NAME, new BPrimitiveType(_NewUserNameChange), new JObject() { [UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID }); } Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, UserKey, _UpdateFieldsUserEntry); var NewEmail = _NewEmailChange ?? (string)_UserObject[UserDBEntry.USER_EMAIL_PROPERTY]; var NewUserName = _NewUserNameChange ?? (string)_UserObject[UserDBEntry.USER_NAME_PROPERTY]; Controller_UserActions.Get().BroadcastUserAction(new Action_UserUpdated( RequestedUserID, OldEmail ?? NewEmail, NewEmail, OldUserName ?? NewUserName, NewUserName, _UpdateFieldsUserEntry), _ErrorMessageAction); } if (_UpdateFieldsAuthEntry.Count > 0) { var UserData = JsonConvert.DeserializeObject <UserDBEntry>(_UserObject.ToString()); if (UserData.AuthMethods != null && UserData.AuthMethods.Count > 0) { foreach (var Method in UserData.AuthMethods) { string PasswordMD5 = null; string OldField = null; BPrimitiveType AuthMethodKey = null; switch (Method.Method) { case AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD: { PasswordMD5 = Method.PasswordMD5; OldField = Method.UserEmail; AuthMethodKey = new BPrimitiveType(Method.UserEmail + PasswordMD5); break; } case AuthMethod.Methods.USER_NAME_PASSWORD_METHOD: { PasswordMD5 = Method.PasswordMD5; OldField = Method.UserName; AuthMethodKey = new BPrimitiveType(Method.UserName + PasswordMD5); break; } case AuthMethod.Methods.API_KEY_METHOD: AuthMethodKey = new BPrimitiveType(Method.ApiKey); break; } if (AuthMethodKey != null) { bool bRecreateNeed = (_NewEmailChange != null && Method.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD) || (_NewUserNameChange != null && Method.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD); if (bRecreateNeed) { MemoryService.DeleteKey(CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + AuthMethodKey.AsString, _ErrorMessageAction); //No in-memory recreation for security. if (!DatabaseService.DeleteItem( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, AuthMethodKey, out JObject DeletedAuthMethodObject, EBReturnItemBehaviour.ReturnAllOld, _ErrorMessageAction)) { DatabaseService.GetItem( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, AuthMethodKey, AuthDBEntry.Properties, out DeletedAuthMethodObject, _ErrorMessageAction); Controller_DeliveryEnsurer.Get().DB_DeleteItem_FireAndForget( _Context, AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, AuthMethodKey); } if (DeletedAuthMethodObject != null) { DeletedAuthMethodObject.Merge(_UpdateFieldsAuthEntry, new JsonMergeSettings() { MergeArrayHandling = MergeArrayHandling.Replace }); _UpdateFieldsAuthEntry = DeletedAuthMethodObject; } if (_NewEmailChange != null && Method.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD) { AuthMethodKey = new BPrimitiveType(_NewEmailChange + PasswordMD5); } else if (_NewUserNameChange != null && Method.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD) { AuthMethodKey = new BPrimitiveType(_NewUserNameChange + PasswordMD5); } Controller_DeliveryEnsurer.Get().DB_PutItem_FireAndForget( _Context, AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, AuthMethodKey, _UpdateFieldsAuthEntry); } else { Controller_DeliveryEnsurer.Get().DB_UpdateItem_FireAndForget( _Context, AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, AuthMethodKey, _UpdateFieldsAuthEntry); } } } } } return(BWebResponse.StatusOK("User has been updated.")); }
private void Cleanup_AuthMethods(Action <string> _ErrorMessageAction = null) { if (!DatabaseService.ScanTable( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), out List <JObject> AuthEntries, _ErrorMessageAction)) { _ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Table does not exist or ScanTable operation has failed."); return; } if (AuthEntries.Count == 0) { return; } foreach (var Current in AuthEntries) { var Casted = JsonConvert.DeserializeObject <AuthDBEntry>(Current.ToString()); var EntryKey = (string)Current[AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY]; if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction)) { continue; } try { bool bDeleteEntry = false; if (!DatabaseService.GetItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(Casted.UserID), UserDBEntry.Properties, out JObject UserObject, _ErrorMessageAction)) { continue; } if (UserObject == null) { //User does not exist bDeleteEntry = true; } else { bool bFound = false; bool bSSOMethod = false; bool bSSORefreshTokenExpired = false; var User = JsonConvert.DeserializeObject <UserDBEntry>(UserObject.ToString()); for (var i = 0; i < User.AuthMethods.Count; i++) { var UserAuthMethod = User.AuthMethods[i]; var UserAuthMethodKey = ""; if (UserAuthMethod.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD) { if (UserAuthMethod.UserEmail == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserEmail.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0) { continue; } UserAuthMethodKey = UserAuthMethod.UserEmail + UserAuthMethod.PasswordMD5; if (UserAuthMethodKey == EntryKey) { bFound = true; //SSO Auth Method Expiry Check if (UserAuthMethod.UserEmail.EndsWith(Controller_SSOAccessToken.EMAIL_USER_NAME_POSTFIX)) { bSSOMethod = true; var QueryParameters = Controller_SSOAccessToken.MakeSSOQueryParameters(UserAuthMethod.PasswordMD5); if (Controller_SSOAccessToken.IsTokenExpiredOrInvalid(out Dictionary <string, BPrimitiveType> _Result, MemoryService, QueryParameters, _ErrorMessageAction) || _Result == null) { bSSORefreshTokenExpired = true; User.AuthMethods.RemoveAt(i); } } break; } } else { if (UserAuthMethod.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD) { if (UserAuthMethod.UserName == null || UserAuthMethod.PasswordMD5 == null || UserAuthMethod.UserName.Length == 0 || UserAuthMethod.PasswordMD5.Length == 0) { continue; } UserAuthMethodKey = UserAuthMethod.UserName + UserAuthMethod.PasswordMD5; } else if (UserAuthMethod.Method == AuthMethod.Methods.API_KEY_METHOD) { UserAuthMethodKey = UserAuthMethod.ApiKey; } if (UserAuthMethodKey == EntryKey) { bFound = true; break; } } } if (!bFound) { bDeleteEntry = true; } else if (bSSOMethod && bSSORefreshTokenExpired) { _ErrorMessageAction?.Invoke("Cleanup_AuthMethods: Expired sso auth method has been found. Deleting the entry."); bDeleteEntry = true; DatabaseService.UpdateItem( UserDBEntry.DBSERVICE_USERS_TABLE(), UserDBEntry.KEY_NAME_USER_ID, new BPrimitiveType(Casted.UserID), JObject.Parse(JsonConvert.SerializeObject(User)), out JObject _, EBReturnItemBehaviour.DoNotReturn, null, _ErrorMessageAction); } } if (bDeleteEntry) { DatabaseService.DeleteItem( AuthDBEntry.DBSERVICE_AUTHMETHODS_TABLE(), AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY, new BPrimitiveType(EntryKey), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction); MemoryService.DeleteKey( CommonData.MemoryQueryParameters, AuthDBEntry.KEY_NAME_AUTH_DB_ENTRY + EntryKey, _ErrorMessageAction); } } finally { Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), Casted.UserID, _ErrorMessageAction); } } }
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction) { if (_Context.Request.HttpMethod != "POST") { _ErrorMessageAction?.Invoke("StopProcessRequest: POST methods is accepted. But received request method: " + _Context.Request.HttpMethod); return(BWebResponse.MethodNotAllowed("POST methods is accepted. But received request method: " + _Context.Request.HttpMethod)); } string BucketName = null; string RelativeFilename = null; string ConversionID_FromRelativeUrl_UrlEncoded = null; using (var InputStream = _Context.Request.InputStream) { var NewObjectJson = new JObject(); using (var ResponseReader = new StreamReader(InputStream)) { try { var ParsedBody = JObject.Parse(ResponseReader.ReadToEnd()); if (!ParsedBody.ContainsKey("bucketName") || !ParsedBody.ContainsKey("rawFileRelativeUrl")) { return(BWebResponse.BadRequest("Request body must contain all necessary fields.")); } var BucketNameToken = ParsedBody["bucketName"]; var RawFileRelativeUrlToken = ParsedBody["rawFileRelativeUrl"]; if (BucketNameToken.Type != JTokenType.String || RawFileRelativeUrlToken.Type != JTokenType.String) { return(BWebResponse.BadRequest("Request body contains invalid fields.")); } BucketName = (string)BucketNameToken; ConversionID_FromRelativeUrl_UrlEncoded = WebUtility.UrlEncode((string)RawFileRelativeUrlToken); RelativeFilename = (string)RawFileRelativeUrlToken; } catch (Exception e) { _ErrorMessageAction?.Invoke("Read request body stage has failed. Exception: " + e.Message + ", Trace: " + e.StackTrace); return(BWebResponse.BadRequest("Malformed request body. Request must be a valid json form.")); } } } //Temporarily, TODO: Change this when the implementation is in place. if (!DatabaseService.DeleteItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded), out JObject _, EBReturnItemBehaviour.DoNotReturn, _ErrorMessageAction)) { if (!DatabaseService.GetItem( FileConversionDBEntry.DBSERVICE_FILE_CONVERSIONS_TABLE(), FileConversionDBEntry.KEY_NAME_CONVERSION_ID, new BPrimitiveType(ConversionID_FromRelativeUrl_UrlEncoded), FileConversionDBEntry.Properties, out JObject _ReturnObject, _ErrorMessageAction) || _ReturnObject != null) { return(BWebResponse.InternalError("Database error.")); } } if (!BatchProcessingCreationService.Instance.StopBatchProcess(BucketName, RelativeFilename, _ErrorMessageAction)) { return(BWebResponse.InternalError("Failed to stop pod or connect to kubernetess")); } return(BWebResponse.StatusAccepted("Request has been accepted; process is now being stopped.")); }