private static unsafe void HandleSessionError(IntPtr sessionHandlePtr, ErrorCode errorCode, byte *messageBuffer, IntPtr messageLength, IntPtr userInfoPairs, int userInfoPairsLength)
{
var handle = new SessionHandle(sessionHandlePtr);
var session = new Session(handle);
var message = Encoding.UTF8.GetString(messageBuffer, (int)messageLength);
SessionException exception;
if (errorCode.IsClientResetError())
{
var userInfo = MarshalErrorUserInfo(userInfoPairs, userInfoPairsLength);
exception = new ClientResetException(message, userInfo);
}
else if (errorCode == ErrorCode.PermissionDenied)
{
var userInfo = MarshalErrorUserInfo(userInfoPairs, userInfoPairsLength);
exception = new PermissionDeniedException(message, userInfo);
}
else
{
exception = new SessionException(message, errorCode);
}
Session.RaiseError(session, exception);
}
private static unsafe void HandleSessionError(IntPtr sessionHandlePtr, ErrorCode errorCode, byte *messageBuffer, IntPtr messageLength, IntPtr userInfoPairs, int userInfoPairsLength, bool isClientReset)
{
try
{
var handle = new SessionHandle(sessionHandlePtr);
var session = new Session(handle);
var message = Encoding.UTF8.GetString(messageBuffer, (int)messageLength);
SessionException exception;
if (isClientReset)
{
var userInfo = StringStringPair.UnmarshalDictionary(userInfoPairs, userInfoPairsLength);
exception = new ClientResetException(session.User.App, message, userInfo);
}
else if (errorCode == ErrorCode.PermissionDenied)
{
var userInfo = StringStringPair.UnmarshalDictionary(userInfoPairs, userInfoPairsLength);
exception = new PermissionDeniedException(session.User.App, message, userInfo);
}
else
{
exception = new SessionException(message, errorCode);
}
Session.RaiseError(session, exception);
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
}
public void OnMsg(ReliableTransferMsg msg)
{
if (netFail)
{
return;
}
StreamTransferSession session;
ArgCollection args;
AppRef appRef;
AppPackageInfo packageInfo;
string path;
args = ArgCollection.Parse(msg.Args);
appRef = AppRef.Parse(args["appref"]);
if (msg.Direction == TransferDirection.Upload)
{
path = packageFolder.BeginTransit(appRef);
session = StreamTransferSession.ServerUpload(router, msg, path);
session.BeginTransfer(onTransfer, new TransferInfo(session, path, msg.Direction));
}
else
{
packageInfo = packageFolder.GetPackageInfo(appRef);
if (packageInfo == null)
{
throw SessionException.Create(null, "Package [{0}] cannot be found.", appRef);
}
path = packageInfo.FullPath;
session = StreamTransferSession.ServerDownload(router, msg, path);
session.BeginTransfer(onTransfer, new TransferInfo(session, path, msg.Direction));
}
}
public void OnMsg(AppStoreMsg msg)
{
if (netFail)
{
return;
}
try
{
switch (msg.Command)
{
case AppStoreQuery.RemoveCmd:
packageFolder.Remove(msg.AppRef);
break;
case AppStoreQuery.SyncCmd:
using (TimedLock.Lock(syncLock))
{
this.forceSync = true;
this.primaryPollTime = SysTime.Now;
}
break;
default:
throw SessionException.Create("Unexpected AppStore command [{0}].", msg.Command);
}
}
catch (Exception e)
{
SysLog.LogException(e);
}
}
private void SessionExceptionHandler(IInvocation invocation, SessionException exception)
{
var methodName = invocation.Method.Name;
var message = $"{exception.Message} error in method {methodName}.";
this._loggerService.LogMessage(message, LogLevel.Error);
this._loggerService.LogMessage(
new LogMessage
{
ClassName = this.ToString(),
Message = exception.Message,
MethodName = invocation.Method.Name
},
LogLevel.Debug);
throw new System.ServiceModel.FaultException <ExceptionDetail>(
new ExceptionDetail(
false,
exception.Message,
description: methodName,
status: exception.errorCode != 0 ? exception.errorCode : ErrorCode.SessionError,
exceptionType: exception.GetType(),
loginAttempts: exception.attemptsLeft,
blockedTill: exception.blockedTill
),
message
);
}
public static async Task RefreshAccessTokenAsync(Session session, bool reportErrors = true)
{
var user = session.User;
if (user == null)
{
return;
}
try
{
var json = new Dictionary <string, object>
{
["data"] = user.RefreshToken,
["path"] = session.ServerUri.AbsolutePath,
["provider"] = "realm",
["app_id"] = AppId
};
var result = await MakeAuthRequestAsync(HttpMethod.Post, new Uri(user.ServerUri, "auth"), json)
.ConfigureAwait(continueOnCapturedContext: false);
var syncWorker = result["sync_worker"];
if (syncWorker != null)
{
session.Handle.SetUrlPrefix(syncWorker["path"].Value <string>());
}
var accessToken = result["access_token"];
var token_data = accessToken["token_data"];
session.Handle.SetMultiplexIdentifier(token_data["sync_label"].Value <string>());
session.Handle.RefreshAccessToken(accessToken["token"].Value <string>(), token_data["path"].Value <string>());
ScheduleTokenRefresh(user.Identity, user.ServerUri, session.Path, _date_1970.AddSeconds(accessToken["token_data"]["expires"].Value <long>()));
}
catch (HttpException ex) when(_connectivityStatusCodes.Contains(ex.StatusCode))
{
// 30 seconds is an arbitrarily chosen value, consider rationalizing it.
ScheduleTokenRefresh(user.Identity, user.ServerUri, session.Path, DateTimeOffset.UtcNow.AddSeconds(30));
}
catch (Exception ex)
{
if (reportErrors)
{
var sessionException = new SessionException("An error has occurred while refreshing the access token.",
ErrorCode.BadUserAuthentication,
ex);
Session.RaiseError(session, sessionException);
}
}
finally
{
// session.User creates a new user each time, so it's safe to dispose the handle here.
// It won't actually corrupt the state of the session.
user.Handle.Dispose();
}
}
private void RaiseSessionExceptionEvent(Exception ex)
{
if (SessionException == null)
{
return;
}
foreach (EventHandler <TcpIpSessionExceptionEventArgs> del in SessionException.GetInvocationList())
{
del.BeginInvoke(this, new TcpIpSessionExceptionEventArgs(ex),
AsyncCallBackRaiseSessionExceptionEvent, del);
}
}
private static unsafe void HandleSessionWaitCallback(IntPtr taskCompletionSource, int error_code, byte *messageBuffer, IntPtr messageLength)
{
var handle = GCHandle.FromIntPtr(taskCompletionSource);
var tcs = (TaskCompletionSource <object>)handle.Target;
if (error_code == 0)
{
tcs.TrySetResult(null);
}
else
{
var inner = new SessionException(Encoding.UTF8.GetString(messageBuffer, (int)messageLength), (ErrorCode)error_code);
const string OuterMessage = "A system error occurred while waiting for completion. See InnerException for more details";
tcs.TrySetException(new RealmException(OuterMessage, inner));
}
}
private static unsafe void HandleOpenRealmCallback(IntPtr taskCompletionSource, IntPtr realm_reference, int error_code, byte *messageBuffer, IntPtr messageLength)
{
var handle = GCHandle.FromIntPtr(taskCompletionSource);
var tcs = (TaskCompletionSource <ThreadSafeReferenceHandle>)handle.Target;
if (error_code == 0)
{
tcs.TrySetResult(new ThreadSafeReferenceHandle(realm_reference, isRealmReference: true));
}
else
{
var inner = new SessionException(Encoding.UTF8.GetString(messageBuffer, (int)messageLength), (ErrorCode)error_code);
const string OuterMessage = "A system error occurred while opening a Realm. See InnerException for more details";
tcs.TrySetException(new RealmException(OuterMessage, inner));
}
}
private static SessionException CreateInvalidResponseException(ICollection <KeyValuePair <string, string> > metaData, HttpStatusCode statusCode)
{
var ex = new SessionException(
string.Format(
SessionResources.DynamoDB_ErrorInResponse, Enum.GetName(typeof(HttpStatusCode), statusCode)));
if (metaData != null && metaData.Count > 0)
{
foreach (var pair in metaData)
{
ex.Data.Add(pair.Key, pair.Value);
}
}
return(ex);
}
private void RaiseSessionExceptionEvent(Exception ex)
{
if (SessionException == null)
{
return;
}
foreach (EventHandler <TcpIpSessionExceptionEventArgs> del in SessionException.GetInvocationList())
{
#if NET40
del.BeginInvoke(this, new TcpIpSessionExceptionEventArgs(ex),
AsyncCallBackRaiseSessionExceptionEvent, del);
#else
System.Threading.Tasks.Task.Run(() => del.Invoke(this, new TcpIpSessionExceptionEventArgs(ex)));
#endif
}
}
internal static Exception TranslateFaultException(FaultException <SessionFault> innerException)
{
Exception exception = null;
if (innerException != null)
{
string errorMessage = innerException.Reason.GetMatchingTranslation().Text;
switch (innerException.Detail.Code)
{
case (int)SOAFaultCode.NoAvailableBrokerNodes:
errorMessage = SR.NoBrokerNodeFound;
break;
case (int)SOAFaultCode.StorageSpaceNotSufficient:
errorMessage = SR.StorageSpaceNotSufficient;
break;
case (int)SOAFaultCode.OperationTimeout:
exception = new TimeoutException(innerException.Detail.Reason);
break;
case (int)SOAFaultCode.AccessDenied_Broker:
case (int)SOAFaultCode.AccessDenied_BrokerLauncher:
case (int)SOAFaultCode.AccessDenied_BrokerQueue:
case (int)SOAFaultCode.AuthenticationFailure:
exception = new AuthenticationException(GenerateErrorMessage(innerException.Detail, errorMessage), innerException);
break;
case (int)SOAFaultCode.ConfigFile_Invalid:
exception = new ConfigurationErrorsException(GenerateErrorMessage(innerException.Detail, errorMessage), innerException);
break;
default:
// If no such string is found, null is returned
errorMessage = GenerateErrorMessage(innerException.Detail, errorMessage);
break;
}
if (exception == null)
{
exception = new SessionException(innerException.Detail.Code, errorMessage);
}
}
return(exception);
}
private static unsafe void HandleSessionError(IntPtr sessionHandlePtr, ErrorCode errorCode, sbyte *messageBuffer, IntPtr messageLength, IntPtr userInfoPairs, int userInfoPairsLength)
{
var session = Session.Create(sessionHandlePtr);
var message = new string(messageBuffer, 0, (int)messageLength, Encoding.UTF8);
SessionException exception;
if (errorCode.IsClientResetError())
{
var userInfo = MarshalErrorUserInfo(userInfoPairs, userInfoPairsLength);
exception = new ClientResetException(message, userInfo);
}
else
{
exception = new SessionException(message, errorCode);
}
Session.RaiseError(session, exception);
}
public static async Task RefreshAccessToken(Session session, bool reportErrors = true)
{
var user = session.User;
try
{
var json = new JsonObject
{
["data"] = user.RefreshToken,
["path"] = session.ServerUri.AbsolutePath,
["provider"] = "realm"
};
var result = await MakeAuthRequestAsync(user.ServerUri, json, TimeSpan.FromSeconds(30)).ConfigureAwait(continueOnCapturedContext: false);
var access_token = result["access_token"];
session.Handle.RefreshAccessToken(access_token["token"], access_token["token_data"]["path"]);
ScheduleTokenRefresh(user.Identity, session.Path, _date_1970.AddSeconds(access_token["token_data"]["expires"]));
}
catch (HttpException ex) when(_connectivityStatusCodes.Contains(ex.StatusCode))
{
// 30 seconds is an arbitrarily chosen value, consider rationalizing it.
ScheduleTokenRefresh(user.Identity, session.Path, DateTimeOffset.UtcNow.AddSeconds(30));
}
catch (Exception ex)
{
if (reportErrors)
{
var sessionException = new SessionException("An error has occurred while refreshing the access token.",
ErrorCode.BadUserAuthentication,
ex);
Session.RaiseError(session, sessionException);
}
}
finally
{
// session.User creates a new user each time, so it's safe to dispose the handle here.
// It won't actually corrupt the state of the session.
user.Handle.Dispose();
}
}
private void FireException(string Message, EFlags ExceptionCode, string Token)
{
SessionException exception = new SessionException();
exception.SetMessage(Message);
exception.Token = Token;
exception.ExceptionCode = ExceptionCode;
string Url = GetDefaultUrl();
if (Url != null)
{
throw exception;
}
else
{
throw new ApplicationException("Session expire. Please login again.");
}
}
public void OnMsg(AppStoreQuery msg)
{
if (netFail)
{
return;
}
var ack = new AppStoreAck();
try
{
switch (msg.Command)
{
case AppStoreQuery.GetPrimaryCmd:
ack.StoreEP = this.PrimaryEP;
break;
case AppStoreQuery.ListCmd:
ack.Packages = packageFolder.GetPackages();
break;
case AppStoreQuery.RemoveCmd:
packageFolder.Remove(msg.AppRef);
break;
case AppStoreQuery.SyncCmd:
using (TimedLock.Lock(syncLock))
{
this.forceSync = true;
this.primaryPollTime = SysTime.Now;
}
break;
case AppStoreQuery.DownloadCmd:
ack.StoreEP = cluster.InstanceEP;
MsgEP primaryEP;
PendingDownload pending;
using (TimedLock.Lock(syncLock))
{
if (packageFolder.GetPackageInfo(msg.AppRef) != null)
{
break; // The package is ready for downloading
}
if (mode == AppStoreMode.Primary || this.PrimaryEP == null)
{
throw SessionException.Create(null, "Package [{0}] cannot be found.", msg.AppRef);
}
primaryEP = this.PrimaryEP;
downloads.TryGetValue(msg.AppRef, out pending);
}
if (pending != null)
{
// A download is already pending for this package so wait
// for it to complete.
pending.Wait();
}
else
{
// Try downloading the requested package from the primary
// application store.
string transitPath = null;
pending = new PendingDownload(msg.AppRef);
using (TimedLock.Lock(syncLock))
downloads.Add(msg.AppRef, pending);
try
{
transitPath = packageFolder.BeginTransit(msg.AppRef);
DownloadPackage(primaryEP, msg.AppRef, transitPath);
packageFolder.EndTransit(transitPath, true);
pending.Done(null);
}
catch (Exception e)
{
packageFolder.EndTransit(transitPath, false);
pending.Done(e);
throw;
}
finally
{
using (TimedLock.Lock(syncLock))
{
try
{
downloads.Remove(msg.AppRef);
}
catch
{
// Ignore errors
}
}
}
}
break;
default:
throw SessionException.Create("Unexpected AppStore command [{0}].", msg.Command);
}
}
catch (Exception e)
{
ack.Exception = e.Message;
SysLog.LogException(e);
}
router.ReplyTo(msg, ack);
}