public BWebServiceResponse ProcessRequest(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
bDoNotGetDBClearance =
BWebUtilities.DoesContextContainHeader(out List <string> DNGDBCs, out string _, _Context, "do-not-get-db-clearance") &&
BUtility.CheckAndGetFirstStringFromList(DNGDBCs, out string DNGDBC) &&
DNGDBC == "true";
BTaskWrapper.Run(() =>
{
var Response = OnRequestCallback?.Invoke(_Context, _ErrorMessageAction);
if (Response.HasValue)
{
Responses.Enqueue(Response.Value);
}
try
{
WaitUntilSignal.Set();
}
catch (Exception) { }
});
try
{
WaitUntilSignal.WaitOne();
}
catch (Exception) { }
if (!Responses.TryDequeue(out BWebServiceResponse FirstResponse))
{
FirstResponse = BWebResponse.InternalError("Unexpected error in concurrence.");
}
return(FirstResponse);
}
/// <summary>
///
/// <para>DeleteCustomTopicGlobally:</para>
///
/// <para>Deletes all messages and the topic of given workspace</para>
///
/// <para>Check <seealso cref="IBPubSubServiceInterface.DeleteCustomTopicGlobally"/> for detailed documentation</para>
///
/// </summary>
public void DeleteCustomTopicGlobally(string _CustomTopic, Action <string> _ErrorMessageAction = null)
{
if (BUtility.CalculateStringMD5(_CustomTopic, out string TopicMD5, _ErrorMessageAction) &&
CheckQueueExists(TopicMD5, out string QueueUrl))
{
try
{
lock (SubscriberThreadsDictionaryLock)
{
if (SubscriberThreadsDictionary.ContainsKey(_CustomTopic))
{
var SubscriberThread = SubscriberThreadsDictionary[_CustomTopic];
if (SubscriberThread != null)
{
SubscriberThread.Item2.Set(true);
}
SubscriberThreadsDictionary.Remove(_CustomTopic);
}
}
using (var DeleteQueueTask = SQSClient.DeleteQueueAsync(QueueUrl))
{
DeleteQueueTask.Wait();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->DeleteCustomTopicGlobally->Callback: " + e.Message + ", Trace: " + e.StackTrace);
if (e.InnerException != null && e.InnerException != e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->DeleteCustomTopicGlobally->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
}
}
}
}
public override void OnDrawGizmosSelected()
{
UnityEngine.Vector3 position = transform.position;
UnityEngine.Quaternion rotation = transform.rotation;
UnityEngine.Vector3 scale = m_localScaling;
BUtility.DebugDrawCylinder(position, rotation, scale, halfExtent.x, halfExtent.y, 2, Color.yellow);
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
bIsInternalCall =
BWebUtilities.DoesContextContainHeader(out List <string> ICHVs, out string _, _Context, "internal-call-secret") &&
BUtility.CheckAndGetFirstStringFromList(ICHVs, out string ICH) &&
ICH == CommonData.INTERNAL_CALL_PRIVATE_KEY;
if (_Context.Request.HttpMethod != "DELETE")
{
_ErrorMessageAction?.Invoke("User_DeleteUserAccessMethod_ForUser: DELETE method is accepted. But received request method: " + _Context.Request.HttpMethod);
return(BWebResponse.MethodNotAllowed("DELETE methods is accepted. But received request method: " + _Context.Request.HttpMethod));
}
RequestedUserID = RestfulUrlParameters[RestfulUrlParameter_UsersKey];
RequestedAuthMethodKey = WebUtility.UrlDecode(RestfulUrlParameters[RestfulUrlParameter_AccessMethodKey]);
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Atomic operation control has failed."));
}
var Result = DeleteAccessMethodForUser(_Context, out bool bSetClearanceForApiKey, out string ApiKey, _ErrorMessageAction);
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction);
if (bSetClearanceForApiKey)
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + ApiKey, _ErrorMessageAction);
}
return(Result);
}
public override BWebServiceResponse OnRequest(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
bool bIsInternalCall =
BWebUtilities.DoesContextContainHeader(out List <string> ICHVs, out string _, _Context, "internal-call-secret") &&
BUtility.CheckAndGetFirstStringFromList(ICHVs, out string _);
if (bIsInternalCall)
{
var ErrorMessages = new JArray();
var Result = OnRequestPP(_Context, (string _Message) =>
{
_ErrorMessageAction?.Invoke(_Message);
ErrorMessages.Add(_Message);
});
try
{
if (Result.ResponseContent.Type == EBStringOrStreamEnum.String)
{
var Parsed = JObject.Parse(Result.ResponseContent.String);
Parsed["internalCallErrorMessages"] = ErrorMessages;
Result = new BWebServiceResponse(Result.StatusCode, Result.Headers, new BStringOrStream(Parsed.ToString()), Result.ResponseContentType);
}
}
catch (Exception) {}
return(Result);
}
return(OnRequestPP(_Context, _ErrorMessageAction));
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (_Context.Request.HttpMethod != "POST" && _Context.Request.HttpMethod != "DELETE")
{
_ErrorMessageAction?.Invoke("User_UpdateDeleteBaseRight_ForUser: POST and DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod);
return(BWebResponse.MethodNotAllowed("POST and DELETE methods are accepted. But received request method: " + _Context.Request.HttpMethod));
}
RequestedUserID = RestfulUrlParameters[RestfulUrlParameter_UsersKey];
RequestedBaseRightWildcard = WebUtility.UrlDecode(RestfulUrlParameters[RestfulUrlParameter_BaseAccessRightsKey]);
RequestedBaseRightWildcard_Regex = BUtility.WildCardToRegular(RequestedBaseRightWildcard);
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Atomic operation control has failed."));
}
BWebServiceResponse Result;
if (_Context.Request.HttpMethod == "POST")
{
Result = UpdateBaseRightForUser(_Context, _ErrorMessageAction);
}
else
{
Result = DeleteBaseRightForUser(_Context, _ErrorMessageAction);
}
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UserDBEntry.DBSERVICE_USERS_TABLE(), RequestedUserID, _ErrorMessageAction);
return(Result);
}
/// <summary>
///
/// <para>ScanTable</para>
///
/// <para>Scans the table for attribute specified by _Key</para>
///
/// <para>Check <seealso cref="IBDatabaseServiceInterface.ScanTable"/> for detailed documentation</para>
///
/// </summary>
public bool ScanTable(string _Table, out List <JObject> _ReturnItem, Action <string> _ErrorMessageAction = null)
{
_ReturnItem = null;
var Table = GetTable(_Table);
if (Table == null)
{
return(false);
}
List <JObject> Results = new List <JObject>();
var Filter = Builders <BsonDocument> .Filter.Empty;
IFindFluent <BsonDocument, BsonDocument> ReturnedSearch;
try
{
ReturnedSearch = Table.Find(Filter);
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BDatabaseServiceMongoDB->ScanTable: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
if (ReturnedSearch != null)
{
List <JObject> TempResults = new List <JObject>();
try
{
foreach (var Document in ReturnedSearch.ToList())
{
var CreatedJson = BsonToJObject(Document);
BUtility.SortJObject(CreatedJson, true);
TempResults.Add(CreatedJson);
}
_ReturnItem = TempResults;
}
catch (Newtonsoft.Json.JsonReaderException e)
{
_ErrorMessageAction?.Invoke("BDatabaseServiceAWS->ScanTable: JsonReaderException: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
return(true);
}
else
{
_ErrorMessageAction?.Invoke("BDatabaseServiceAWS->ScanTable: TableObject.ScanTable returned null.");
}
return(false);
}
private bool MakeQueryParameters(out BMemoryQueryParameters _QueryParameters, out string _PasswordMD5_FromAccessToken)
{
_QueryParameters = new BMemoryQueryParameters();
if (!BUtility.CalculateStringMD5(AccessToken_TokenTypeSpacePrepended, out _PasswordMD5_FromAccessToken, ErrorMessageAction))
{
return(false);
}
_QueryParameters = MakeSSOQueryParameters(_PasswordMD5_FromAccessToken);
return(true);
}
/// <summary>
///
/// <para>CustomPublish:</para>
///
/// <para>Publishes the given message to given custom topic</para>
///
/// <para>Check <seealso cref="IBPubSubServiceInterface.CustomPublish"/> for detailed documentation</para>
///
/// </summary>
public bool CustomPublish(string _CustomTopic, string _CustomMessage, Action <string> _ErrorMessageAction = null)
{
if (_CustomTopic != null && _CustomTopic.Length > 0 &&
_CustomMessage != null && _CustomMessage.Length > 0 &&
BUtility.CalculateStringMD5(_CustomTopic, out string TopicMD5, _ErrorMessageAction))
{
if (EnsureQueueExists(TopicMD5, out string QueueUrl, _ErrorMessageAction))
{
string TimestampHash = null;
UniqueMessageDeliveryEnsurer?.Publish_PrependTimestampToMessage(ref _CustomMessage, out TimestampHash);
try
{
if (UniqueMessageDeliveryEnsurer != null)
{
if (UniqueMessageDeliveryEnsurer.Publish_EnsureUniqueDelivery(_CustomTopic, TimestampHash, _ErrorMessageAction))
{
using (var SendMessageTask = SQSClient.SendMessageAsync(QueueUrl, _CustomMessage))
{
SendMessageTask.Wait();
}
}
else
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomPublish: UniqueMessageDeliveryEnsurer has failed.");
return(false);
}
}
else
{
using (var SendMessageTask = SQSClient.SendMessageAsync(QueueUrl, _CustomMessage))
{
SendMessageTask.Wait();
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomPublish: " + e.Message + ", Trace: " + e.StackTrace);
if (e.InnerException != null && e.InnerException != e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomPublish->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
}
return(false);
}
return(true);
}
}
return(false);
}
public static bool Initialize(
out BServiceInitializer _Result,
string[][] _RequiredExtraEnvVars = null)
{
var Instance = new BServiceInitializer();
_Result = null;
Instance.LoggingService = new BLoggingServiceBasic();
var RequiredEnvVarKeys = new List <string[]>()
{
new string[] { "PORT" },
new string[] { "PROGRAM_ID" }
};
if (_RequiredExtraEnvVars != null)
{
RequiredEnvVarKeys.AddRange(_RequiredExtraEnvVars);
}
/*
* Getting environment variables
*/
if (!BUtility.GetEnvironmentVariables(out Instance._RequiredEnvironmentVariables,
RequiredEnvVarKeys.ToArray(),
(string Message) =>
{
Instance.LoggingService.WriteLogs(BLoggingServiceMessageUtility.Single(EBLoggingServiceLogType.Critical, Message), Instance.ProgramID, "Initialization");
}))
{
return(false);
}
Instance.ProgramID = Instance.RequiredEnvironmentVariables["PROGRAM_ID"];
/*
* Parsing http server port
*/
if (!int.TryParse(Instance.RequiredEnvironmentVariables["PORT"], out int _ServPort))
{
Instance.LoggingService.WriteLogs(BLoggingServiceMessageUtility.Single(EBLoggingServiceLogType.Critical, "Given http server port is invalid."), Instance.ProgramID, "Initialization");
return(false);
}
Instance.ServerPort = _ServPort;
_Result = Instance;
return(true);
}
private bool TestDeleteLocalFile()
{
bool bLocalFailure = false;
//Test delete local file
PrintAction?.Invoke("TestDeleteLocalFile->Log-> Testing DeleteLocalFile...");
BUtility.DeleteFile(FileLocalPath, (string Message) =>
{
PrintAction?.Invoke("TestDeleteLocalFile->Error-> " + Message);
bLocalFailure = true;
});
if (bLocalFailure)
{
PrintAction?.Invoke("TestDeleteLocalFile->Error-> DeleteLocalFile failed.");
return(false);
}
PrintAction?.Invoke("TestDeleteLocalFile->Log-> DeleteLocalFile succeed.");
return(true);
}
private BWebServiceResponse OnRequest_CreateTestUser(HttpListenerContext _Context, Action <string> _ErrorMessageAction)
{
string OptionalName = BUtility.RandomString(12, true) + "_test";
string EmailWithoutPostfix = OptionalName + "@test.com";
var AccumulatedSSOMethodRightsOrDefault = new JArray()
{
JObject.Parse(JsonConvert.SerializeObject(
new AccessScope()
{
WildcardPath = "*",
AccessRights = new List <string>()
{
"GET", "POST", "PUT", "DELETE"
}
}))
};
if (!CreateUser(out string _UserID, EmailWithoutPostfix, _ErrorMessageAction, OptionalName))
{
return(BWebResponse.InternalError("User creation process has been failed."));
}
if (!CreateAuthMethod(out string _ApiKey, _UserID, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Auth method creation process has been failed."));
}
if (!Controller_Rights_Internal.Get().GrantUserWithRights(false, _UserID, AccumulatedSSOMethodRightsOrDefault, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Grant user with rights process has been failed."));
}
return(BWebResponse.StatusCreated("User has been created.", new JObject()
{
[UserDBEntry.KEY_NAME_USER_ID] = _UserID,
[AuthMethod.API_KEY_PROPERTY] = _ApiKey,
[AuthMethod.USER_EMAIL_PROPERTY] = EmailWithoutPostfix
}));
}
public bool GetCallbackFromRequest(out Func <BWebServiceBase> _Initializer, out string _MatchedPrefix, HttpListenerContext _Context)
{
_Initializer = null;
_MatchedPrefix = null;
if (_Context == null || Prefixes_SortedByLength == null || Prefixes_SortedByLength.Length == 0 || ListenerInitializer == null)
{
return(false);
}
for (var i = (Prefixes_SortedByLength.Length - 1); i >= 0; i--)
{
var Prefix = Prefixes_SortedByLength[i];
if (Regex.IsMatch(_Context.Request.RawUrl, BUtility.WildCardToRegular(Prefix)))
{
_MatchedPrefix = Prefix;
_Initializer = ListenerInitializer;
return(_Initializer != null);
}
}
return(false);
}
private static void AnalyzeResponse(
HttpWebResponse _Response,
out bool _bHttpRequestSuccess,
out int _HttpRequestResponseCode,
out string _HttpRequestResponseContentType,
out BStringOrStream _HttpRequestResponseContent,
out Dictionary <string, IEnumerable <string> > _HttpRequestResponseHeaders,
Action <string> _ErrorMessageAction)
{
_bHttpRequestSuccess = false;
_HttpRequestResponseCode = BWebResponse.Error_InternalError_Code;
_HttpRequestResponseContentType = "";
_HttpRequestResponseContent = null;
_HttpRequestResponseHeaders = new Dictionary <string, IEnumerable <string> >();
try
{
_HttpRequestResponseCode = (int)_Response.StatusCode;
BWebUtilities.InjectHeadersIntoDictionary(_Response.Headers, _HttpRequestResponseHeaders);
_HttpRequestResponseContentType = _Response.ContentType;
using (var ResStream = _Response.GetResponseStream())
{
var CopyStream = new BMemoryTributary(BUtility.ReadToEnd(ResStream));
_HttpRequestResponseContent = new BStringOrStream(CopyStream, CopyStream.Length, () => { try { CopyStream?.Dispose(); } catch { } });
}
_bHttpRequestSuccess = true;
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Error: RequestRedirection-AnalyzeResponse: " + e.Message + ", Trace: " + e.StackTrace);
_bHttpRequestSuccess = false;
}
}
public static bool CheckBaseFinalFullContainment(List <AccessScope> _BaseScopeList, List <AccessScope> _FinalScopeList)
{
foreach (var FinalScope in _FinalScopeList)
{
bool bFound = false;
foreach (var BaseScope in _BaseScopeList)
{
//Checked
if (Regex.IsMatch(FinalScope.WildcardPath, BUtility.WildCardToRegular(BaseScope.WildcardPath)))
{
bool bAccessRightsExist = true;
foreach (var FinalAccessRight in FinalScope.AccessRights)
{
if (!BaseScope.AccessRights.Contains(FinalAccessRight))
{
bAccessRightsExist = false;
break;
}
}
if (bAccessRightsExist)
{
bFound = true;
break;
}
}
}
if (!bFound)
{
return(false);
}
}
return(true);
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (_Context.Request.HttpMethod != "POST")
{
_ErrorMessageAction?.Invoke("SSOAzureTokenRefreshRequest: POST method is accepted. But received request method: " + _Context.Request.HttpMethod);
return(BWebResponse.MethodNotAllowed("POST method is accepted. But received request method: " + _Context.Request.HttpMethod));
}
if (!BWebUtilities.DoesContextContainHeader(out List <string> ClientAuthorizationHeaderValues, out string _, _Context, "client-authorization") ||
!BUtility.CheckAndGetFirstStringFromList(ClientAuthorizationHeaderValues, out string ClientAuthorization) ||
ClientAuthorization.Length == 0)
{
return(BWebResponse.BadRequest("Authorization header must be set validly."));
}
//Check and try refresh if expired
if (new Controller_SSOAccessToken(ClientAuthorization, DatabaseService, MemoryService, AzureAD_AppID, AzureAD_ClientSecret, SSOSuperAdmins, _ErrorMessageAction)
.PerformCheckAndRefresh(
out Controller_SSOAccessToken.EPerformCheckAndRefreshSuccessStatus SuccessStatus,
out ClientAuthorization,
out string UserID,
out string EmailAddressWithoutPostfix) &&
ClientAuthorization != null && ClientAuthorization.Length > 0)
{
return(BWebResponse.StatusOK("Success.", new JObject()
{
["token"] = ClientAuthorization,
["status"] = SuccessStatus == Controller_SSOAccessToken.EPerformCheckAndRefreshSuccessStatus.Refreshed ? "Refreshed" : "AlreadyValid",
["userId"] = UserID,
["email"] = EmailAddressWithoutPostfix
}));
}
return(BWebResponse.Unauthorized("Please re-login."));
}
public static bool GenerateNonExistentUniqueID(
WebServiceBaseTimeoutable _Request,
IBDatabaseServiceInterface _DatabaseService,
string _TableName,
string _TableKeyName,
string[] _TableEntryMustHaveProperties,
EGetClearance _GetClearance,
out string _GeneratedUniqueID,
out BWebServiceResponse _FailureResponse,
Action <string> _ErrorMessageAction = null)
{
_GeneratedUniqueID = null;
_FailureResponse = BWebResponse.InternalError("");
int ExistenceTrial = 0;
while (_GeneratedUniqueID == null && ExistenceTrial < 3)
{
if (!BUtility.CalculateStringMD5(BUtility.RandomString(32, false), out _GeneratedUniqueID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Hashing operation has failed.");
return(false);
}
if (_GetClearance == EGetClearance.Yes && !Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(_Request.InnerProcessor, _TableName, _GeneratedUniqueID, _ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Atomic operation control has failed.");
return(false);
}
if (!_DatabaseService.GetItem(
_TableName,
_TableKeyName,
new BPrimitiveType(_GeneratedUniqueID),
_TableEntryMustHaveProperties,
out JObject ExistenceCheck,
_ErrorMessageAction))
{
_FailureResponse = BWebResponse.InternalError("Database existence check operation has failed.");
return(false);
}
if (ExistenceCheck != null)
{
if (_GetClearance == EGetClearance.Yes)
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(_Request.InnerProcessor, _TableName, _GeneratedUniqueID, _ErrorMessageAction);
}
_GeneratedUniqueID = null;
ExistenceTrial++;
}
else
{
break;
}
}
if (_GeneratedUniqueID == null)
{
_FailureResponse = BWebResponse.InternalError("Unique model ID generation operation has failed.");
return(false);
}
return(true);
}
public static InterServicesRequestResponse InterServicesRequest(
InterServicesRequestRequest _Request,
bool _bKillProcessOnAddAccessTokenForServiceExecutionFailure = true,
Action <string> _ErrorMessageAction = null)
{
var bHttpRequestSuccess = false;
var HttpRequestResponseCode = BWebResponse.Error_InternalError_Code;
var HttpRequestResponseContentType = "";
BStringOrStream HttpRequestResponseContent = null;
Dictionary <string, IEnumerable <string> > HttpRequestResponseHeaders = null;
var Request = (HttpWebRequest)WebRequest.Create(_Request.DestinationServiceUrl);
Request.Method = _Request.RequestMethod;
Request.ServerCertificateValidationCallback = (a, b, c, d) => true;
Request.AllowAutoRedirect = false;
if (_Request.bWithAuthToken)
{
//If context-headers already contain authorization; we must rename it to client-authorization to prevent override.
if (_Request.UseContextHeaders != null &&
BWebUtilities.DoesContextContainHeader(out List <string> AuthorizationHeaderValues, out string CaseSensitive_FoundHeaderKey, _Request.UseContextHeaders, "authorization") &&
BUtility.CheckAndGetFirstStringFromList(AuthorizationHeaderValues, out string ClientAuthorization))
{
_Request.UseContextHeaders.Request.Headers.Remove(CaseSensitive_FoundHeaderKey);
_Request.UseContextHeaders.Request.Headers.Add("client-authorization", ClientAuthorization);
}
}
var ExcludeHeaderKeysForRequest = LowerContentOfStrings(_Request.ExcludeHeaderKeysForRequest);
if (_Request.UseContextHeaders != null)
{
InsertHeadersFromContextInto(_Request.UseContextHeaders, (string _Key, string _Value) =>
{
if (ExcludeHeaderKeysForRequest != null && ExcludeHeaderKeysForRequest.Contains(_Key.ToLower()))
{
return;
}
Request.Headers.Add(_Key, _Value);
});
}
if (_Request.Headers != null)
{
InsertHeadersFromDictionaryInto(_Request.Headers, (string _Key, string _Value) =>
{
if (ExcludeHeaderKeysForRequest != null && ExcludeHeaderKeysForRequest.Contains(_Key.ToLower()))
{
return;
}
Request.Headers.Add(_Key, _Value);
});
}
try
{
if (_Request.RequestMethod != "GET" && /*&& _Request.RequestMethod != "DELETE"*/
_Request.Content != null && ((_Request.Content.Type == EBStringOrStreamEnum.Stream && _Request.Content.Stream != null) || (_Request.Content.Type == EBStringOrStreamEnum.String && _Request.Content.String != null && _Request.Content.String.Length > 0)))
{
Request.ContentType = _Request.ContentType;
using (var OStream = Request.GetRequestStream())
{
if (_Request.Content.Type == EBStringOrStreamEnum.Stream)
{
_Request.Content.Stream.CopyTo(OStream);
}
else
{
using (var RStream = new StreamWriter(OStream))
{
RStream.Write(_Request.Content.String);
}
}
}
}
try
{
using (var Response = (HttpWebResponse)Request.GetResponse())
{
AnalyzeResponse(Response, out bHttpRequestSuccess, out HttpRequestResponseCode, out HttpRequestResponseContentType, out HttpRequestResponseContent, out HttpRequestResponseHeaders, _ErrorMessageAction);
}
}
catch (Exception e)
{
if (e is WebException)
{
using (var ErrorResponse = (HttpWebResponse)(e as WebException).Response)
{
AnalyzeResponse(ErrorResponse, out bHttpRequestSuccess, out HttpRequestResponseCode, out HttpRequestResponseContentType, out HttpRequestResponseContent, out HttpRequestResponseHeaders, _ErrorMessageAction);
}
}
else
{
_ErrorMessageAction?.Invoke("Error: InterServicesRequest: " + e.Message + ", Trace: " + e.StackTrace);
bHttpRequestSuccess = false;
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("Error: InterServicesRequest: " + e.Message + ", Trace: " + e.StackTrace);
bHttpRequestSuccess = false;
}
if (!bHttpRequestSuccess)
{
_ErrorMessageAction?.Invoke("Error: Request has failed due to an internal api gateway error. Service endpoint: " + _Request.DestinationServiceUrl);
return(InterServicesRequestResponse.InternalErrorOccured("Request has failed due to an internal api gateway error."));
}
if (_Request.UseContextHeaders != null)
{
InsertHeadersFromDictionaryIntoContext(HttpRequestResponseHeaders, _Request.UseContextHeaders);
}
return(new InterServicesRequestResponse()
{
bSuccess = true,
ResponseCode = HttpRequestResponseCode,
ContentType = HttpRequestResponseContentType,
ResponseHeaders = HttpRequestResponseHeaders,
Content = HttpRequestResponseContent
});
}
private BWebServiceResponse OnRequest_Internal(HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
if (!UrlParameters.TryGetValue("redirect_url", out string RedirectUrlEncoded) || RedirectUrlEncoded.Length == 0)
{
RedirectUrlEncoded = DEFAULT_REDIRECT_URL_ENCODED;
}
if (_Context.Request.HttpMethod != "GET")
{
_ErrorMessageAction?.Invoke("SSOLoginRequest: GET method is accepted. But received request method: " + _Context.Request.HttpMethod);
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), true, BWebResponse.Error_BadRequest_Code, "GET method is accepted. But received request method: " + _Context.Request.HttpMethod));
}
if (!UrlParameters.TryGetValue("tenant", out string TenantName) || TenantName.Length == 0)
{
TenantName = DEFAULT_TENANT_NAME;
}
else
{
TenantName = TenantName.ToLower();
}
//Existing token from header
string ClientAuthorization = null;
if (BWebUtilities.DoesContextContainHeader(out List <string> ClientAuthorizationHeaderValues, out string _, _Context, "client-authorization"))
{
BUtility.CheckAndGetFirstStringFromList(ClientAuthorizationHeaderValues, out ClientAuthorization);
if (ClientAuthorization != null && ClientAuthorization.Length == 0)
{
ClientAuthorization = null;
}
}
//Existing token from url parameters
//Note: Must be token type prepended. Example: ?existing_token=bearer%20abc123123
if (!UrlParameters.TryGetValue("existing_token", out string ExistingToken) || ExistingToken.Length == 0)
{
ExistingToken = null;
}
else
{
ExistingToken = WebUtility.UrlDecode(ExistingToken);
}
//If both existing tokens are non-null; it is error
if (ClientAuthorization != null && ExistingToken != null)
{
_ErrorMessageAction?.Invoke("Error: SSOLoginRequest: Both existing tokens from url parameters and headers are non-null.");
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), true, BWebResponse.Error_BadRequest_Code, "Both existing tokens from url parameters and headers are non-null."));
}
//From now on, use ClientAuthorization; not ExistingToken
if (ExistingToken != null)
{
ClientAuthorization = ExistingToken;
}
//Check and try refresh if expired
if (ClientAuthorization != null &&
new Controller_SSOAccessToken(ClientAuthorization, DatabaseService, MemoryService, AzureAD_AppID, AzureAD_ClientSecret, SSOSuperAdmins, _ErrorMessageAction)
.PerformCheckAndRefresh(
out Controller_SSOAccessToken.EPerformCheckAndRefreshSuccessStatus _,
out ClientAuthorization,
out string UserID,
out string _))
{
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), false, 0, null, UserID, ClientAuthorization));
}
//Get api passthrough endpoint from internal set state
var LocalErrorString = "";
if (!InternalSetState.GetValueFromMemoryService(
out string ApiPassthroughEndpoint,
InternalSetState.API_PASSTHROUGH_PUBLIC_ENDPOINT_PROPERTY,
MemoryService,
(string _Message) =>
{
LocalErrorString = _Message;
_ErrorMessageAction?.Invoke(_Message);
}))
{
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), true, 500, LocalErrorString));
}
string ServersideRedirectUrl = WebUtility.UrlEncode(ApiPassthroughEndpoint + "/auth/login/azure/callback");
string AzureAuthenticationEndpointBase =
"https://login.microsoftonline.com/common/oauth2/v2.0/authorize"
+ "?client_id=" + AzureAD_AppID
+ "&response_type=id_token code"
+ "&redirect_uri=" + ServersideRedirectUrl;
var TrialCount = 0;
string SSOStateUniqueID;
BMemoryQueryParameters SSOStateUniqueID_QueryParameters;
do
{
if (!BUtility.CalculateStringMD5(BUtility.RandomString(32, true), out SSOStateUniqueID, _ErrorMessageAction))
{
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), true, 500, "SSO State ID generation has failed."));
}
SSOStateUniqueID_QueryParameters = SSOStateMEntry.ID_SSO_STATE_MEMORY_SERVICE_KEY(SSOStateUniqueID);
if (!MemoryService.SetKeyValueConditionally(
SSOStateUniqueID_QueryParameters,
new Tuple <string, BPrimitiveType>(
SSOStateMEntry.HASH_KEY,
new BPrimitiveType(JsonConvert.SerializeObject(
new SSOStateMEntry()
{
ServersideRedirectUrl = ServersideRedirectUrl,
TenantName = TenantName,
Status = SSOStateMEntry.STATUS_AUTHENTICATING
})
)
),
_ErrorMessageAction))
{
SSOStateUniqueID = null;
}
} while (SSOStateUniqueID == null && ++TrialCount < 5);
if (SSOStateUniqueID == null)
{
return(SSOCommon.MakeCallerRedirected(WebUtility.UrlDecode(RedirectUrlEncoded), true, 500, "Unique SSO State ID generation has failed."));
}
MemoryService.SetKeyExpireTime(SSOStateUniqueID_QueryParameters, TimeSpan.FromSeconds(120), _ErrorMessageAction);
var AzureAuthenticationEndpoint = AzureAuthenticationEndpointBase
+ "&scope=" + SSOCommon.SCOPE_URL_ENCODED
+ "&response_mode=form_post"
+ "&nonce=" + SSOStateUniqueID
+ "&state="
+ WebUtility.UrlEncode(
"redirect_url=" + RedirectUrlEncoded +
"&tenant=" + TenantName +
"&state=" + SSOStateUniqueID);
return(SSOCommon.MakeCallerRedirected(AzureAuthenticationEndpoint, false, 0, null));
}
/// <summary>
///
/// <para>CustomSubscribe:</para>
///
/// <para>Subscribes to given custom topic</para>
///
/// <para>Check <seealso cref="IBPubSubServiceInterface.CustomSubscribe"/> for detailed documentation</para>
///
/// </summary>
public bool CustomSubscribe(string _CustomTopic, Action <string, string> _OnMessage, Action <string> _ErrorMessageAction = null, bool _SubscribeSingleMessage = false)
{
if (_CustomTopic != null && _CustomTopic.Length > 0 && _OnMessage != null && BUtility.CalculateStringMD5(_CustomTopic, out string TopicMD5, _ErrorMessageAction))
{
if (EnsureQueueExists(TopicMD5, out string QueueUrl, _ErrorMessageAction))
{
var SubscriptionCancellationVar = new BValue <bool>(false, EBProducerStatus.MultipleProducer);
var SubscriptionThread = new Thread(() =>
{
Thread.CurrentThread.IsBackground = true;
while (!SubscriptionCancellationVar.Get())
{
ReceiveMessageResponse Response;
try
{
using (var ReceiveMessageTask = SQSClient.ReceiveMessageAsync(QueueUrl))
{
ReceiveMessageTask.Wait();
Response = ReceiveMessageTask.Result;
}
}
catch (Exception e)
{
Response = null;
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomSubscribe: " + e.Message + ", Trace: " + e.StackTrace);
if (e.InnerException != null && e.InnerException != e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomSubscribe->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
}
}
if (Response == null || Response.Messages == null || Response.Messages.Count == 0)
{
Thread.Sleep(1000);
continue;
}
var AckDictionary = new Dictionary <string, string>();
foreach (var MessageContainer in Response.Messages)
{
if (MessageContainer != null)
{
if (!AckDictionary.ContainsKey(MessageContainer.MessageId))
{
AckDictionary.Add(MessageContainer.MessageId, MessageContainer.ReceiptHandle);
}
string Data = MessageContainer.Body;
if (UniqueMessageDeliveryEnsurer != null)
{
UniqueMessageDeliveryEnsurer.Subscribe_ClearAndExtractTimestampFromMessage(ref Data, out string TimestampHash);
if (UniqueMessageDeliveryEnsurer.Subscription_EnsureUniqueDelivery(_CustomTopic, TimestampHash, _ErrorMessageAction))
{
_OnMessage?.Invoke(_CustomTopic, Data);
}
}
else
{
_OnMessage?.Invoke(_CustomTopic, Data);
}
}
}
var AckArray = new List <DeleteMessageBatchRequestEntry>();
foreach (var Current in AckDictionary)
{
AckArray.Add(new DeleteMessageBatchRequestEntry(Current.Key, Current.Value));
}
try
{
using (var DeleteMessageBatchTask = SQSClient.DeleteMessageBatchAsync(QueueUrl, AckArray))
{
DeleteMessageBatchTask.Wait();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomSubscribe: " + e.Message + ", Trace: " + e.StackTrace);
if (e.InnerException != null && e.InnerException != e)
{
_ErrorMessageAction?.Invoke("BPubSubServiceAWS->CustomSubscribe->Inner: " + e.InnerException.Message + ", Trace: " + e.InnerException.StackTrace);
}
}
}
});
SubscriptionThread.Start();
lock (SubscriberThreadsDictionaryLock)
{
SubscriberThreadsDictionary.Add(_CustomTopic, new BTuple <Thread, BValue <bool> >(SubscriptionThread, SubscriptionCancellationVar));
}
return(true);
}
}
return(false);
}
private bool AccessCheck(out BWebServiceResponse _FailureResponse, out bool _bSSOTokenRefreshed, out string _NewSSOTokenAfterRefresh, HttpListenerContext _Context, Action <string> _ErrorMessageAction = null)
{
_FailureResponse = new BWebServiceResponse();
_bSSOTokenRefreshed = false;
_NewSSOTokenAfterRefresh = "";
if (bAuthCheck)
{
//Check for authorization header
if (!BWebUtilities.DoesContextContainHeader(out List <string> Authorization, out string _, _Context, "authorization"))
{
_FailureResponse = BWebResponse.Unauthorized("Authorization header must be set.");
return(false);
}
var RequestObject = new JObject()
{
["forUrlPath"] = _Context.Request.RawUrl,
["requestMethod"] = _Context.Request.HttpMethod
};
if (BUtility.CheckAndGetFirstStringFromList(Authorization, out string _Authorization))
{
RequestObject["authorization"] = _Authorization;
}
else //Zero length
{
_FailureResponse = BWebResponse.Unauthorized("Authorization header must be set.");
return(false);
}
GetTracingService()?.On_FromGatewayToService_Sent(_Context, _ErrorMessageAction);
var Result = BWebServiceExtraUtilities.InterServicesRequest(new BWebServiceExtraUtilities.InterServicesRequestRequest()
{
DestinationServiceUrl = AuthServiceBaseUrl + "/auth/access_check",
RequestMethod = "POST",
ContentType = "application/json",
Content = new BStringOrStream(RequestObject.ToString()),
bWithAuthToken = true,
UseContextHeaders = _Context,
},
false,
_ErrorMessageAction);
GetTracingService()?.On_FromServiceToGateway_Received(_Context, _ErrorMessageAction);
if (!Result.bSuccess || Result.ResponseCode >= 400)
{
if (Result.ResponseCode == BWebResponse.Error_Unauthorized_Code ||
Result.ResponseCode == BWebResponse.Error_Forbidden_Code)
{
_FailureResponse = new BWebServiceResponse(Result.ResponseCode, Result.Content, Result.ContentType);
return(false);
}
_ErrorMessageAction?.Invoke("Access check internal call has failed: Response: " + Result.ResponseCode + " -> " + Result.Content.String + ", Request: " + RequestObject.ToString());
_FailureResponse = BWebResponse.InternalError("Internal access check call has failed.");
return(false);
}
var ResponseContent = Result.Content.ToString();
try
{
var Parsed = JObject.Parse(ResponseContent);
Authenticated_UserID = (string)Parsed["userId"];
Authenticated_UserName = (string)Parsed["userName"];
Authenticated_UserEmail = (string)Parsed["userEmail"];
Authenticated_AuthMethodKey = (string)Parsed["authMethodKey"];
_bSSOTokenRefreshed = (bool)Parsed["ssoTokenRefreshed"];
_NewSSOTokenAfterRefresh = (string)Parsed["newSSOTokenAfterRefresh"];
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("HandleRequest->AccessCheck: Error during content parse: " + ResponseContent + ", Message: " + e.Message + ", Trace: " + e.StackTrace);
_FailureResponse = BWebResponse.InternalError("Request has failed due to an internal api gateway error.");
return(false);
}
_Context.Request.Headers.Set("authorized-u-id", Authenticated_UserID);
_Context.Request.Headers.Set("authorized-u-name", Authenticated_UserName);
_Context.Request.Headers.Set("authorized-u-email", Authenticated_UserEmail);
_Context.Request.Headers.Set("authorized-u-auth-key", Authenticated_AuthMethodKey);
}
return(true);
}
public static bool GenerateUserID(out string _NewUserID, Action <string> _ErrorMessageAction)
{
return(BUtility.CalculateStringMD5(BUtility.RandomString(32, true), out _NewUserID, _ErrorMessageAction));
}
/// <summary>
///
/// <para>DownloadFile:</para>
///
/// <para>Downloads a file from File Service and stores locally/or to stream, caller thread will be blocked before it is done</para>
///
/// <para>Check <seealso cref="IBFileServiceInterface.DownloadFile"/> for detailed documentation</para>
///
/// </summary>
public bool DownloadFile(string _BucketName, string _KeyInBucket, BStringOrStream _Destination, Action <string> _ErrorMessageAction = null, ulong _StartIndex = 0, ulong _Size = 0)
{
BlobContainerClient ContainerClient = AServiceClient.GetBlobContainerClient(_BucketName);
BlobClient Blob = ContainerClient.GetBlobClient(_KeyInBucket);
Response <BlobProperties> Response = Blob.GetProperties();
if (AServiceClient == null)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: AServiceClient is null.");
return(false);
}
if (!CheckFileExistence(
_BucketName,
_KeyInBucket,
out bool bExists,
_ErrorMessageAction
))
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: CheckFileExistence failed.");
return(false);
}
if (!bExists)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: File does not exist in the File Service.");
return(false);
}
HttpRange Range = default(HttpRange);
if (_Size > 0)
{
Range = new HttpRange((long)_StartIndex, (long)(_StartIndex + _Size));
}
try
{
if (_Destination.Type == EBStringOrStreamEnum.String)
{
using (FileStream FS = File.Create(_Destination.String))
{
BlobDownloadInfo DlInfo = Blob.Download(Range).Value;
DlInfo.Content.CopyTo(FS);
DlInfo.Dispose();
}
if (!BUtility.DoesFileExist(
_Destination.String,
out bool bLocalFileExists,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: DoesFileExist failed.");
return(false);
}
if (!bLocalFileExists)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: Download finished, but still file does not locally exist.");
return(false);
}
}
else
{
if (_Destination.Stream == null)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: Destination stream is null.");
return(false);
}
BlobDownloadInfo DlInfo = Blob.Download(Range).Value;
DlInfo.Content.CopyTo(_Destination.Stream);
DlInfo.Dispose();
try
{
_Destination.Stream.Position = 0;
}
catch (Exception) { }
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->DownloadFile: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
return(true);
}
public static bool RunTests()
{
if (!BUtility.GetEnvironmentVariables(out Dictionary <string, string> RequiredEnvVars,
new string[][]
{
new string[] { "GC_PROJECT_ID" }
},
Console.WriteLine))
{
return(false);
}
/*
* Logging Services tests
*/
var LoggingTests_GC = new BLoggingServiceTest(
new BLoggingServiceGC(
RequiredEnvVars["GC_PROJECT_ID"],
Console.WriteLine),
Console.WriteLine);
if (!LoggingTests_GC.Start())
{
return(false);
}
var LoggingTests_AWS = new BLoggingServiceTest(
new BLoggingServiceAWS(
RequiredEnvVars["AWS_ACCESS_KEY"],
RequiredEnvVars["AWS_SECRET_KEY"],
RequiredEnvVars["AWS_REGION"],
Console.WriteLine),
Console.WriteLine);
if (!LoggingTests_AWS.Start())
{
return(false);
}
var LoggingTests_Azure = new BLoggingServiceTest(
new BLoggingServiceAzure(
RequiredEnvVars["APPINSIGHTS_INSTRUMENTATIONKEY"],
Console.WriteLine),
Console.WriteLine);
if (!LoggingTests_Azure.Start())
{
return(false);
}
/*
* E-mail Services tests
*/
var Comparator = new BRelativeTestsResultComparator(Console.WriteLine);
var MailTests_SendGrid = new BEmailServicesTest(
new BMailServiceSendGrid(
RequiredEnvVars["SENDGRID_API_KEY"],
"*****@*****.**",
"BTest",
Console.WriteLine),
Comparator.AddLine);
if (!MailTests_SendGrid.Start())
{
return(false);
}
/*
* Database Services tests
*/
Comparator = new BRelativeTestsResultComparator(Console.WriteLine);
var DBTests_GC = new BDatabaseServicesTest(
new BDatabaseServiceGC(
RequiredEnvVars["GC_PROJECT_ID"],
Console.WriteLine),
"BTest",
"TestKey",
Comparator.AddLine);
if (!DBTests_GC.Start())
{
return(false);
}
Comparator.Next();
var DBTests_AWS = new BDatabaseServicesTest(
new BDatabaseServiceAWS(
RequiredEnvVars["AWS_ACCESS_KEY"],
RequiredEnvVars["AWS_SECRET_KEY"],
RequiredEnvVars["AWS_REGION"],
Console.WriteLine),
"BTest",
"TestKey",
Comparator.AddLine);
if (!DBTests_AWS.Start())
{
return(false);
}
Comparator.Next();
var DBTests_MongoDB = new BDatabaseServicesTest(
new BDatabaseServiceMongoDB(
RequiredEnvVars["MONGO_DB_CONNECTION_STRING"],
RequiredEnvVars["MONGO_DB_DATABASE"],
Console.WriteLine),
"BTest",
"TestKey",
Comparator.AddLine);
if (!DBTests_MongoDB.Start())
{
return(false);
}
if (!Comparator.Compare())
{
return(false);
}
/*
* Memory and Pub/Sub Services tests
*/
Comparator = new BRelativeTestsResultComparator(Console.WriteLine);
var MemTests_WithRedisPubSub = new BMemoryPubSubServiceTest(
new BMemoryServiceRedis(
RequiredEnvVars["REDIS_ENDPOINT"],
int.Parse(RequiredEnvVars["REDIS_PORT"]),
RequiredEnvVars["REDIS_PASSWORD"],
bool.Parse(RequiredEnvVars["REDIS_SSL_ENABLED"]),
new BPubSubServiceRedis(
RequiredEnvVars["REDIS_ENDPOINT"],
int.Parse(RequiredEnvVars["REDIS_PORT"]),
RequiredEnvVars["REDIS_PASSWORD"],
bool.Parse(RequiredEnvVars["REDIS_SSL_ENABLED"]),
true,
Console.WriteLine),
true,
Console.WriteLine),
Comparator.AddLine);
if (!MemTests_WithRedisPubSub.Start())
{
return(false);
}
Comparator.Next();
var MemTests_WithGCPubSub = new BMemoryPubSubServiceTest(
new BMemoryServiceRedis(
RequiredEnvVars["REDIS_ENDPOINT"],
int.Parse(RequiredEnvVars["REDIS_PORT"]),
RequiredEnvVars["REDIS_PASSWORD"],
bool.Parse(RequiredEnvVars["REDIS_SSL_ENABLED"]),
new BPubSubServiceGC(
RequiredEnvVars["GC_PROJECT_ID"],
Console.WriteLine),
true,
Console.WriteLine),
Comparator.AddLine);
if (!MemTests_WithGCPubSub.Start())
{
return(false);
}
if (!Comparator.Compare())
{
return(false);
}
Comparator.Next();
var MemTests_WithAWSPubSub = new BMemoryPubSubServiceTest(
new BMemoryServiceRedis(
RequiredEnvVars["REDIS_ENDPOINT"],
int.Parse(RequiredEnvVars["REDIS_PORT"]),
RequiredEnvVars["REDIS_PASSWORD"],
bool.Parse(RequiredEnvVars["REDIS_SSL_ENABLED"]),
new BPubSubServiceAWS(
RequiredEnvVars["AWS_ACCESS_KEY"],
RequiredEnvVars["AWS_SECRET_KEY"],
RequiredEnvVars["AWS_REGION"],
Console.WriteLine),
true,
Console.WriteLine),
Comparator.AddLine);
if (!MemTests_WithAWSPubSub.Start())
{
return(false);
}
if (!Comparator.Compare())
{
return(false);
}
Comparator.Next();
var MemTests_WithAzurePubSub = new BMemoryPubSubServiceTest(
new BMemoryServiceRedis(
RequiredEnvVars["REDIS_ENDPOINT"],
int.Parse(RequiredEnvVars["REDIS_PORT"]),
RequiredEnvVars["REDIS_PASSWORD"],
bool.Parse(RequiredEnvVars["REDIS_SSL_ENABLED"]),
new BPubSubServiceAzure(
RequiredEnvVars["AZURE_CLIENT_ID"],
RequiredEnvVars["AZURE_CLIENT_SECRET"],
RequiredEnvVars["AZURE_TENANT_ID"],
RequiredEnvVars["AZURE_NAMESPACE_ID"],
RequiredEnvVars["AZURE_NAMESPACE_CONNSTR"],
Console.WriteLine),
true,
Console.WriteLine),
Comparator.AddLine);
if (!MemTests_WithAWSPubSub.Start())
{
return(false);
}
if (!Comparator.Compare())
{
return(false);
}
/*
* File Services tests
*/
Comparator = new BRelativeTestsResultComparator(Console.WriteLine);
var FSTests_GC = new BFileServiceTest(
new BFileServiceGC(
RequiredEnvVars["GC_PROJECT_ID"],
Console.WriteLine),
RequiredEnvVars["FILESERVICE_BUCKET"],
RequiredEnvVars["FILESERVICE_REMOTE_PATH"],
RequiredEnvVars["FILESERVICE_TEST_FILE_LOCAL_PATH"],
Comparator.AddLine);
if (!FSTests_GC.Start())
{
return(false);
}
Comparator.Next();
var FSTests_AWS = new BFileServiceTest(
new BFileServiceAWS(
RequiredEnvVars["AWS_ACCESS_KEY"],
RequiredEnvVars["AWS_SECRET_KEY"],
RequiredEnvVars["AWS_REGION"],
Console.WriteLine),
RequiredEnvVars["FILESERVICE_BUCKET"],
RequiredEnvVars["FILESERVICE_REMOTE_PATH"],
RequiredEnvVars["FILESERVICE_TEST_FILE_LOCAL_PATH"],
Comparator.AddLine);
if (!FSTests_AWS.Start())
{
return(false);
}
Comparator.Next();
var FSTests_AZ = new BFileServiceTest(
new BFileServiceAZ(
RequiredEnvVars["AZ_STORAGE_SERVICE"],
RequiredEnvVars["AZ_STORAGE_ACCOUNT"],
RequiredEnvVars["AZ_STORAGE_ACCOUNT_KEY"],
RequiredEnvVars["AZ_STORAGE_RESOURCE_GROUP"],
RequiredEnvVars["AZ_STORAGE_MANAGEMENT_APP_ID"],
RequiredEnvVars["AZ_STORAGE_MANAGEMENT_SECRET"],
RequiredEnvVars["AZ_SUBSCRIPTION_ID"],
RequiredEnvVars["AZ_TENANT_ID"],
RequiredEnvVars["AZ_STORAGE_LOCATION"],
Console.WriteLine),
RequiredEnvVars["FILESERVICE_BUCKET"],
RequiredEnvVars["FILESERVICE_REMOTE_PATH"],
RequiredEnvVars["FILESERVICE_TEST_FILE_LOCAL_PATH"],
Comparator.AddLine);
if (!FSTests_AWS.Start())
{
return(false);
}
if (!Comparator.Compare())
{
return(false);
}
return(true);
}
private BWebServiceResponse CreateAccessMethodForUser(HttpListenerContext _Context, out bool _bSetClearanceForApiKey, out string _ApiKey, Action <string> _ErrorMessageAction)
{
_bSetClearanceForApiKey = false;
_ApiKey = null;
AuthMethod NewMethod = null;
using (var InputStream = _Context.Request.InputStream)
{
using (var ResponseReader = new StreamReader(InputStream))
{
try
{
NewMethod = JsonConvert.DeserializeObject <AuthMethod>(ResponseReader.ReadToEnd());
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("User_CreateListAccessMethods_ForUser->CreateAccessMethodForUser: 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 (NewMethod == null)
{
return(BWebResponse.BadRequest("Request body does not contain all mandatory information or some fields are invalid."));
}
BPrimitiveType AuthMethodKey = null;
if (NewMethod.Method == AuthMethod.Methods.USER_EMAIL_PASSWORD_METHOD)
{
if (NewMethod.UserEmail == null || NewMethod.PasswordMD5 == null || NewMethod.UserEmail.Length == 0 || NewMethod.PasswordMD5.Length == 0)
{
return(BWebResponse.BadRequest("Request body does not contain all fields."));
}
AuthMethodKey = new BPrimitiveType(NewMethod.UserEmail + NewMethod.PasswordMD5);
}
else if (NewMethod.Method == AuthMethod.Methods.USER_NAME_PASSWORD_METHOD)
{
if (NewMethod.UserName == null || NewMethod.PasswordMD5 == null || NewMethod.UserName.Length == 0 || NewMethod.PasswordMD5.Length == 0)
{
return(BWebResponse.BadRequest("Request body does not contain all fields."));
}
AuthMethodKey = new BPrimitiveType(NewMethod.UserName + NewMethod.PasswordMD5);
}
else if (NewMethod.Method == AuthMethod.Methods.API_KEY_METHOD)
{
int ExistenceTrial = 0;
while (ExistenceTrial < 3)
{
if (!BUtility.CalculateStringMD5(BUtility.RandomString(32, false), out NewMethod.ApiKey, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Hashing error."));
}
NewMethod.ApiKey = NewMethod.ApiKey.ToUpper();
if (!Controller_AtomicDBOperation.Get().GetClearanceForDBOperation(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + NewMethod.ApiKey, _ErrorMessageAction))
{
return(BWebResponse.InternalError("Atomic operation control has failed."));
}
if (!DatabaseService.UpdateItem(
UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(),
UniqueUserFieldsDBEntry.KEY_NAME_API_KEY,
new BPrimitiveType(NewMethod.ApiKey),
new JObject()
{
[UserDBEntry.KEY_NAME_USER_ID] = RequestedUserID
},
out JObject _,
EBReturnItemBehaviour.DoNotReturn,
DatabaseService.BuildAttributeNotExistCondition(UniqueUserFieldsDBEntry.KEY_NAME_API_KEY),
_ErrorMessageAction))
{
Controller_AtomicDBOperation.Get().SetClearanceForDBOperationForOthers(InnerProcessor, UniqueUserFieldsDBEntry.DBSERVICE_UNIQUEUSERFIELDS_TABLE(), UniqueUserFieldsDBEntry.KEY_NAME_API_KEY + ":" + NewMethod.ApiKey, _ErrorMessageAction);
ExistenceTrial++;
}
else
{
_bSetClearanceForApiKey = true;
_ApiKey = NewMethod.ApiKey;
break;
}
}
static int Main()
{
Console.WriteLine("Initializing the service...");
#if (Debug || DEBUG)
if (!ServicesDebugOnlyUtilities.CalledFromMain())
{
return(1);
}
#endif
// In case of a cloud component dependency or environment variable is added/removed;
// Relative terraform script and microservice-dependency-map.cs must be updated as well.
if (!BUtility.GetEnvironmentVariables(out Dictionary <string, string> EnvironmentVariables,
new string[][]
{
new string[] { "PORT" },
new string[] { "PROGRAM_ID" },
new string[] { "API_GATEWAY_SERVICE_BASE_URL" },
new string[] { "STATIC_STATE_BUCKET" }, //Currently set to ignore on local debugging sessions; since it is only used for maintenance check
new string[] { "DEPLOYMENT_BRANCH_NAME" },
new string[] { "DEPLOYMENT_BUILD_NUMBER" }
},
Console.WriteLine))
{
return(1);
}
Resources_DeploymentManager.Get().SetDeploymentBranchNameAndBuildNumber(EnvironmentVariables["DEPLOYMENT_BRANCH_NAME"], EnvironmentVariables["DEPLOYMENT_BUILD_NUMBER"]);
if (!int.TryParse(EnvironmentVariables["PORT"], out int ServerPort))
{
Console.WriteLine("Invalid PORT environment variable; it must be an integer.");
return(1);
}
string ApiGatewayServiceEndpoint = EnvironmentVariables["API_GATEWAY_SERVICE_BASE_URL"];
string MaintenanceModeCheckUrl = "https://storage.googleapis.com/" + EnvironmentVariables["STATIC_STATE_BUCKET"] + "/maintenance_mode_" + Resources_DeploymentManager.Get().GetDeploymentBranchName();
var DeploymentLoweredBranchName = Resources_DeploymentManager.Get().GetDeploymentBranchNameEscapedLoweredWithDash();
if (DeploymentLoweredBranchName == "master" || DeploymentLoweredBranchName == "development")
{
//If the branch is feature, bugfix, hotfix etc. do not check for maintenance.
MaintenanceChecker.Get().Start(MaintenanceModeCheckUrl, Console.WriteLine);
}
/*
* Web-http service initialization
*/
var WebServiceEndpoints = new List <BWebPrefixStructure>()
{
new BWebPrefixStructure(new string[] { "*" }, () => new PassThroughRequest(ApiGatewayServiceEndpoint))
};
var BWebService = new BWebService(WebServiceEndpoints.ToArray(), ServerPort);
BWebService.Run((string Message) =>
{
Console.WriteLine(Message);
});
/*
* Make main thread sleep forever
*/
Thread.Sleep(Timeout.Infinite);
return(0);
}
/// <summary>
///
/// <para>BTracingServiceGC: Parametered Constructor for Managed Service by Google</para>
///
/// <para>Parameters:</para>
/// <para><paramref name="_ProjectID"/> GC Project ID</para>
/// <para><paramref name="_ProgramUniqueID"/> Program Unique ID</para>
/// <para><paramref name="_ErrorMessageAction"/> Error messages will be pushed to this action</para>
///
/// </summary>
public BTracingServiceGC(
string _ProjectID,
string _ProgramUniqueID,
Action <string> _ErrorMessageAction = null)
{
ProgramUniqueID = _ProgramUniqueID;
ErrorMessageAction = _ErrorMessageAction;
try
{
string ApplicationCredentials = Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS");
string ApplicationCredentialsPlain = Environment.GetEnvironmentVariable("GOOGLE_PLAIN_CREDENTIALS");
if (ApplicationCredentials == null && ApplicationCredentialsPlain == null)
{
_ErrorMessageAction?.Invoke("BTracingServiceGC->Constructor: GOOGLE_APPLICATION_CREDENTIALS (or GOOGLE_PLAIN_CREDENTIALS) environment variable is not defined.");
bInitializationSucceed = false;
}
else
{
var Scopes = new List <string>();
foreach (var Scope in TraceServiceClient.DefaultScopes)
{
if (!Scopes.Contains(Scope))
{
Scopes.Add(Scope);
}
}
if (ApplicationCredentials == null)
{
if (!BUtility.HexDecode(out ApplicationCredentialsPlain, ApplicationCredentialsPlain, _ErrorMessageAction))
{
throw new Exception("Hex decode operation for application credentials plain has failed.");
}
Credential = GoogleCredential.FromJson(ApplicationCredentialsPlain)
.CreateScoped(
Scopes.ToArray())
.UnderlyingCredential as ServiceAccountCredential;
}
else
{
using (var Stream = new FileStream(ApplicationCredentials, FileMode.Open, FileAccess.Read))
{
Credential = GoogleCredential.FromStream(Stream)
.CreateScoped(
Scopes.ToArray())
.UnderlyingCredential as ServiceAccountCredential;
}
}
if (Credential != null)
{
Channel = new Grpc.Core.Channel(
TraceServiceClient.DefaultEndpoint.ToString(),
Credential.ToChannelCredentials());
}
if (Channel != null)
{
TraceClient = TraceServiceClient.Create(Channel);
ProjectName = new Google.Api.Gax.ResourceNames.ProjectName(_ProjectID);
bInitializationSucceed = TraceClient != null;
UploadTimer = new Timer(1_000);
UploadTimer.Elapsed += OnTimedEvent;
UploadTimer.AutoReset = true;
UploadTimer.Enabled = true;
}
else
{
bInitializationSucceed = false;
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BTracingServiceGC->Constructor: " + e.Message + ", Trace: " + e.StackTrace);
bInitializationSucceed = false;
}
}
/// <summary>
///
/// <para>WriteLogs:</para>
///
/// <para>Writes logs to the logging service</para>
///
/// <para>Check <seealso cref="IBLoggingServiceInterface.WriteLogs"/> for detailed documentation</para>
///
/// </summary>
public bool WriteLogs(
List <BLoggingParametersStruct> _Messages,
string _LogGroupName,
string _LogStreamName,
bool _bAsync = true,
Action <string> _ErrorMessageAction = null)
{
if (_Messages == null || _Messages.Count == 0)
{
return(false);
}
if (_bAsync)
{
BTaskWrapper.Run(() =>
{
WriteLogs(_Messages, _LogGroupName, _LogStreamName, false, _ErrorMessageAction);
});
return(true);
}
else
{
_LogGroupName = BUtility.EncodeStringForTagging(_LogGroupName);
_LogStreamName = BUtility.EncodeStringForTagging(_LogStreamName);
string SequenceToken = null;
bool bLogStreamAndGroupExists = false;
try
{
var DescribeStreamRequest = new DescribeLogStreamsRequest(_LogGroupName);
using (var CreatedDescribeTask = CloudWatchLogsClient.DescribeLogStreamsAsync(DescribeStreamRequest))
{
CreatedDescribeTask.Wait();
if (CreatedDescribeTask.Result != null && CreatedDescribeTask.Result.LogStreams != null && CreatedDescribeTask.Result.LogStreams.Count > 0)
{
foreach (var Current in CreatedDescribeTask.Result.LogStreams)
{
if (Current != null && Current.LogStreamName == _LogStreamName)
{
SequenceToken = Current.UploadSequenceToken;
bLogStreamAndGroupExists = true;
break;
}
}
}
}
}
catch (Exception)
{
bLogStreamAndGroupExists = false;
}
if (!bLogStreamAndGroupExists)
{
try
{
var CreateGroupRequest = new CreateLogGroupRequest(_LogGroupName);
using (var CreatedGroupTask = CloudWatchLogsClient.CreateLogGroupAsync(CreateGroupRequest))
{
CreatedGroupTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
try
{
var CreateStreamRequest = new CreateLogStreamRequest(_LogGroupName, _LogStreamName);
using (var CreatedStreamTask = CloudWatchLogsClient.CreateLogStreamAsync(CreateStreamRequest))
{
CreatedStreamTask.Wait();
}
}
catch (Exception e)
{
if (!(e is ResourceAlreadyExistsException))
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
}
var LogEvents = new List <InputLogEvent>();
foreach (var Message in _Messages)
{
var LogEvent = new InputLogEvent()
{
Message = Message.Message,
Timestamp = DateTime.UtcNow
};
switch (Message.LogType)
{
case EBLoggingServiceLogType.Debug:
LogEvent.Message = "Debug-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Info:
LogEvent.Message = "Info-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Warning:
LogEvent.Message = "Warning-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Error:
LogEvent.Message = "Error-> " + LogEvent.Message;
break;
case EBLoggingServiceLogType.Critical:
LogEvent.Message = "Critical-> " + LogEvent.Message;
break;
}
LogEvents.Add(LogEvent);
}
try
{
var PutRequest = new PutLogEventsRequest(_LogGroupName, _LogStreamName, LogEvents)
{
SequenceToken = SequenceToken
};
using (var CreatedPutTask = CloudWatchLogsClient.PutLogEventsAsync(PutRequest))
{
CreatedPutTask.Wait();
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BLoggingServiceAWS->WriteLogs: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
return(true);
}
}
/// <summary>
///
/// <para>UploadFile:</para>
///
/// <para>Uploads a local file to File Service, caller thread will be blocked before it is done</para>
///
/// <para>EBRemoteFileReadPublicity does nothing as Azure does not support per object authentication, only per container</para>
///
/// <para>Check <seealso cref="IBFileServiceInterface.UploadFile"/> for detailed documentation</para>
///
/// </summary>
public bool UploadFile(BStringOrStream _LocalFileOrStream, string _BucketName, string _KeyInBucket, EBRemoteFileReadPublicity _RemoteFileReadAccess = EBRemoteFileReadPublicity.AuthenticatedRead, Tuple <string, string>[] _FileTags = null, Action <string> _ErrorMessageAction = null)
{
if (AServiceClient == null)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: GSClient is null.");
return(false);
}
BlobContainerClient ContainerClient = AServiceClient.GetBlobContainerClient(_BucketName);
BlobClient Blob = ContainerClient.GetBlobClient(_KeyInBucket);
Response <BlobContentInfo> Response = null;
if (_LocalFileOrStream.Type == EBStringOrStreamEnum.String)
{
if (!BUtility.DoesFileExist(
_LocalFileOrStream.String,
out bool bLocalFileExists,
_ErrorMessageAction))
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: DoesFileExist failed.");
return(false);
}
if (!bLocalFileExists)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: Local file does not exist.");
return(false);
}
using (FileStream FS = new FileStream(_LocalFileOrStream.String, FileMode.Open, FileAccess.Read))
{
try
{
Response = Blob.Upload(FS);
if (Response.Value == null)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: Operation has failed.");
return(false);
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
}
else
{
try
{
Response = Blob.Upload(_LocalFileOrStream.Stream);
if (Response.Value == null)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: Operation has failed.");
return(false);
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BFileServiceAZ->UploadFile: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
if (Response != null)
{
if (_FileTags != null && _FileTags.Length > 0)
{
Dictionary <string, string> NewMetadata = new Dictionary <string, string>();
foreach (Tuple <string, string> CurrentTag in _FileTags)
{
NewMetadata.Add(CurrentTag.Item1, CurrentTag.Item2);
}
try
{
Blob.SetMetadata(NewMetadata);
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"BFileServiceAZ->UploadFile: {ex.Message}, Trace: {ex.StackTrace}");
return(false);
}
}
var FileName = _KeyInBucket;
var FileNameIndex = _KeyInBucket.LastIndexOf("/") + 1;
if (FileNameIndex > 0)
{
FileName = _KeyInBucket.Substring(FileNameIndex, _KeyInBucket.Length - FileNameIndex);
}
BlobHttpHeaders Header = new BlobHttpHeaders()
{
ContentDisposition = $"inline; filename={FileName}"
};
try
{
Blob.SetHttpHeaders(Header);
}
catch (Exception ex)
{
_ErrorMessageAction?.Invoke($"BFileServiceAZ->UploadFile: {ex.Message}, Trace: {ex.StackTrace}");
return(false);
}
}
return(true);
}
/// <summary>
///
/// <para>BGoogleSlidesService: Parametered Constructor</para>
///
/// <para>Parameters:</para>
/// <para><paramref name="_ProgramUniqueID"/> Program Unique ID</para>
/// <para><paramref name="_ProjectID"/> GC Project ID</para>
/// <para><paramref name="_ErrorMessageAction"/> Error messages will be pushed to this action</para>
///
/// </summary>
public BGoogleSlidesService(
string _ProgramUniqueID,
string _ProjectID,
Action <string> _ErrorMessageAction = null)
{
ProgramUniqueID = _ProgramUniqueID;
ProjectID = _ProjectID;
try
{
string ApplicationCredentials = Environment.GetEnvironmentVariable("GOOGLE_APPLICATION_CREDENTIALS");
string ApplicationCredentialsPlain = Environment.GetEnvironmentVariable("GOOGLE_PLAIN_CREDENTIALS");
if (ApplicationCredentials == null && ApplicationCredentialsPlain == null)
{
_ErrorMessageAction?.Invoke("BGoogleSlidesService->Constructor: GOOGLE_APPLICATION_CREDENTIALS (or GOOGLE_PLAIN_CREDENTIALS) environment variable is not defined.");
bInitializationSucceed = false;
}
else
{
if (ApplicationCredentials == null)
{
if (!BUtility.HexDecode(out ApplicationCredentialsPlain, ApplicationCredentialsPlain, _ErrorMessageAction))
{
throw new Exception("Hex decode operation for application credentials plain has failed.");
}
Credential = GoogleCredential.FromJson(ApplicationCredentialsPlain)
.CreateScoped(
new string[]
{
SlidesService.Scope.PresentationsReadonly
})
.UnderlyingCredential as ServiceAccountCredential;
}
else
{
using (var Stream = new FileStream(ApplicationCredentials, FileMode.Open, FileAccess.Read))
{
Credential = GoogleCredential.FromStream(Stream)
.CreateScoped(
new string[]
{
SlidesService.Scope.PresentationsReadonly
})
.UnderlyingCredential as ServiceAccountCredential;
}
}
if (Credential != null)
{
bInitializationSucceed = true;
}
else
{
bInitializationSucceed = false;
}
}
}
catch (Exception e)
{
_ErrorMessageAction?.Invoke("BGoogleSlidesService->Constructor: " + e.Message + ", Trace: " + e.StackTrace);
bInitializationSucceed = false;
}
}
