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 IsPropertyAccessException_WithPermissionDeniedException_WithIBusinessObjectWithIdentity_ReturnsTrue()
{
var bindableProperty = CreateBindableProperty((() => ((ClassWithReferenceType <string>)null).Scalar));
var businessObjectStub = MockRepository.GenerateStub <IBusinessObjectWithIdentity>();
businessObjectStub.Stub(_ => _.UniqueIdentifier).Return("TheIdentifier");
var permissionDeniedException = new PermissionDeniedException("The Exception");
BusinessObjectPropertyAccessException actualException;
var actualResult = _strategy.IsPropertyAccessException(
businessObjectStub,
bindableProperty,
permissionDeniedException,
out actualException);
Assert.That(actualResult, Is.True);
Assert.That(actualException, Is.Not.Null);
Assert.That(
actualException.Message,
Is.EqualTo(
"A PermissionDeniedException occured while getting the value of property 'Scalar' for business object with ID 'TheIdentifier'."));
Assert.That(actualException.InnerException, Is.SameAs(permissionDeniedException));
}
public void CreateWithpermission()
{
TestHelpers.EnsureLanguageIsValid();
string permission = "Something";
PermissionDeniedException exception = new PermissionDeniedException(permission);
Assert.AreEqual("Permission to execute 'Something' has been denied.", exception.Message);
Assert.AreEqual(permission, exception.Permission);
}
public void CreateWithpermissionAndMessage()
{
TestHelpers.EnsureLanguageIsValid();
string permission = "Something";
string message = "An error has occured";
PermissionDeniedException exception = new PermissionDeniedException(permission, message);
Assert.AreEqual(message, exception.Message);
Assert.AreEqual(permission, exception.Permission);
}
public void PassThroughSerialisation()
{
TestHelpers.EnsureLanguageIsValid();
string permission = "Something";
PermissionDeniedException exception = new PermissionDeniedException(permission);
object result = TestHelpers.RunSerialisationTest(exception);
Assert.IsNotNull(result);
Assert.That(result, Is.InstanceOf <PermissionDeniedException>());
Assert.AreEqual("Permission to execute 'Something' has been denied.", exception.Message);
Assert.AreEqual(permission, (result as PermissionDeniedException).Permission);
}
public void CheckPermission()
{
var adminAddress = new Address("399bddF9F7B6d902ea27037B907B2486C9910730");
var adminState = new AdminState(adminAddress, 100);
var initStates = ImmutableDictionary <Address, IValue> .Empty
.Add(AdminState.Address, adminState.Serialize())
.Add(TableSheetsState.Address, new TableSheetsState(new Dictionary <string, string>()
{
["TestTable"] = "Initial",
}).Serialize());
var state =
new State(initStates, ImmutableDictionary <(Address, Currency), BigInteger> .Empty);
var action = new PatchTableSheet()
{
TableName = "TestTable",
TableCsv = "New Value",
};
PolicyExpiredException exc1 = Assert.Throws <PolicyExpiredException>(() =>
{
action.Execute(
new ActionContext()
{
BlockIndex = 101,
PreviousStates = state,
Signer = adminAddress,
}
);
});
Assert.Equal(101, exc1.BlockIndex);
PermissionDeniedException exc2 = Assert.Throws <PermissionDeniedException>(() =>
{
action.Execute(
new ActionContext()
{
BlockIndex = 5,
PreviousStates = state,
Signer = new Address("019101FEec7ed4f918D396827E1277DEda1e20D4"),
}
);
});
Assert.Equal(new Address("019101FEec7ed4f918D396827E1277DEda1e20D4"), exc2.Signer);
}
public IActionResult OnException(ExceptionContext context)
{
return(context.Exception switch
{
// 处理权限类异常
PermissionDeniedException permissionDenied => HandleException(context, HttpStatusCode.Forbidden, new
{
Code = permissionDenied.Key
}),
// 处理其他已知类异常
AppException appException => HandleException(context, HttpStatusCode.BadRequest, new
{
Code = appException.Key
}),
// 处理未知类异常
_ => HandleException(context, HttpStatusCode.InternalServerError)
});
public void CheckPermission()
{
var adminAddress = new Address("399bddF9F7B6d902ea27037B907B2486C9910730");
var adminState = new AdminState(adminAddress, 100);
var initStates = ImmutableDictionary <Address, IValue> .Empty
.Add(AdminState.Address, adminState.Serialize());
var state = new State(initStates, ImmutableDictionary <(Address, Currency), FungibleAssetValue> .Empty);
var action = new AddRedeemCode
{
redeemCsv = "New Value",
};
PolicyExpiredException exc1 = Assert.Throws <PolicyExpiredException>(() =>
{
action.Execute(
new ActionContext
{
BlockIndex = 101,
PreviousStates = state,
Signer = adminAddress,
}
);
});
Assert.Equal(101, exc1.BlockIndex);
PermissionDeniedException exc2 = Assert.Throws <PermissionDeniedException>(() =>
{
action.Execute(
new ActionContext
{
BlockIndex = 5,
PreviousStates = state,
Signer = new Address("019101FEec7ed4f918D396827E1277DEda1e20D4"),
}
);
});
Assert.Equal(new Address("019101FEec7ed4f918D396827E1277DEda1e20D4"), exc2.Signer);
}
/// <summary>
/// Intercepts the login attempt in order to provide some internal handling.
/// </summary>
/// <param name="result">Result of the login attempt.</param>
/// <param name="session">Session proxy, if one exists.</param>
/// <param name="e">Exception thrown from the callback.</param>
private void LoginCallback(Result <MainSessionPrx> result)
{
System.Exception e = result.Exception;
if (result.Success)
{
if (KeepAlive)
{
keepAliveTimer = new Timer(new TimerCallback(OnKeepAlive),
null, KeepAliveInterval, KeepAliveInterval);
}
session = result.ReturnedResult;
session.GetTankList();
//session = MainSessionPrxHelper.uncheckedCast(session.ice_router(router));
pinger = new Pinger(session);
}
else
{
logger.Error("LoginCallback() Login attempt failed: {0}", e);
if (e is PermissionDeniedException)
{
PermissionDeniedException ex = (PermissionDeniedException)e;
e = new LoginFailedException(ex.reason);
}
else
{
e = new LoginFailedException("Unable to login.");
}
result.Exception = e;
}
remoteCallback(new Result(result.Success, session, result.Exception));
remoteCallback = null;
}
public void TestExceptions()
{
{
AlreadyExistsException v1 = new AlreadyExistsException("ex");
AlreadyExistsException v2 = (AlreadyExistsException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConfigurationException v1 = new ConfigurationException("ex");
ConfigurationException v2 = (ConfigurationException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectionBrokenException v1 = new ConnectionBrokenException("ex");
ConnectionBrokenException v2 = (ConnectionBrokenException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectionFailedException v1 = new ConnectionFailedException("ex");
ConnectionFailedException v2 = (ConnectionFailedException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorException v1 = new ConnectorException("ex");
ConnectorException v2 = (ConnectorException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorIOException v1 = new ConnectorIOException("ex");
ConnectorIOException v2 = (ConnectorIOException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ConnectorSecurityException v1 = new ConnectorSecurityException("ex");
ConnectorSecurityException v2 = (ConnectorSecurityException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
InvalidCredentialException v1 = new InvalidCredentialException("ex");
InvalidCredentialException v2 = (InvalidCredentialException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
InvalidPasswordException v1 = new InvalidPasswordException("ex");
InvalidPasswordException v2 = (InvalidPasswordException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
PasswordExpiredException v1 = new PasswordExpiredException("ex");
v1.Uid = (new Uid("myuid"));
PasswordExpiredException v2 = (PasswordExpiredException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
Assert.AreEqual("myuid", v2.Uid.GetUidValue());
}
{
OperationTimeoutException v1 = new OperationTimeoutException("ex");
OperationTimeoutException v2 = (OperationTimeoutException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
PermissionDeniedException v1 = new PermissionDeniedException("ex");
PermissionDeniedException v2 = (PermissionDeniedException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
UnknownUidException v1 = new UnknownUidException("ex");
UnknownUidException v2 = (UnknownUidException)CloneObject(v1);
Assert.AreEqual("ex", v2.Message);
}
{
ArgumentException v1 = new ArgumentException("my msg");
ArgumentException v2 = (ArgumentException)CloneObject(v1);
Assert.AreEqual("my msg", v2.Message);
}
{
ArgumentNullException v1 = new ArgumentNullException(null, "my msg 1");
ArgumentException v2 = (ArgumentException)CloneObject(v1);
Assert.AreEqual("my msg 1", v2.Message);
}
{
Exception v1 = new Exception("my msg2");
Exception v2 = (Exception)CloneObject(v1);
Assert.AreEqual("my msg2", v2.Message);
}
}
public static void ThrowPermissionDeniedException(PermissionDeniedException ex)
{
ErrorData e = new v2.ErrorData(ex, "permission-denied");
throw new WebFaultException <Error>(new Error(e), HttpStatusCode.Forbidden);
}
