public IOperationData OperationData(Type type)
{
if (_operationData != null)
{
return(_operationData);
}
bool isCrud = OperationConstants.IsCrud(_operationName) || typeof(CrudOperationData) == type;
if (isCrud)
{
return(EntityBuilder.BuildFromJson <CrudOperationData>(typeof(CrudOperationData), _entityMetadata, _applicationMetadata, _json, _id));
}
var data = (OperationData)_json.ToObject(type);
data.EntityMetadata = EntityMetadata;
if (!typeof(CrudOperationDataContainer).IsAssignableFrom(type))
{
return(data);
}
JToken crudFields;
if (!_json.TryGetValue("crud", out crudFields))
{
throw new InvalidOperationException(String.Format(CrudFieldNotFound, OperationName, _entityMetadata.Name));
}
((CrudOperationDataContainer)data).CrudData = EntityBuilder.BuildFromJson <CrudOperationData>(typeof(CrudOperationData), _entityMetadata, _applicationMetadata, (JObject)crudFields, _id);
data.ApplicationMetadata = _applicationMetadata;
_operationData = data;
return(data);
}
public OperationWrapper(CrudOperationData operationData, String operationName)
{
_entityMetadata = operationData.EntityMetadata;
_id = operationData.Id;
_operationName = operationName;
_operationData = operationData;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public OauthMember GetMemberByGrant(IOperationData pData, string pGrantCode)
{
Member path = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.OauthGrantCode, pGrantCode);
return(GetOauthMember(pData, path, "GetMemberByGrant"));
}
/*--------------------------------------------------------------------------------------------*/
private OauthMember GetOauthMember(IOperationData pData, Member pMemPath, string pName)
{
IWeaverVarAlias <Member> memAlias;
IWeaverQuery memQ = pMemPath.ToQueryAsVar("m", out memAlias);
IWeaverQuery appQ = Weave.Inst.FromVar(memAlias)
.DefinedByApp.ToApp
.Property(x => x.VertexId)
.ToQuery();
IDataAccess acc = pData.Build(null, true);
acc.AddSessionStart();
acc.AddQuery(memQ, true);
acc.AppendScriptToLatestCommand("(m?m=m.next():null);");
string memCmdId = acc.GetLatestCommandId();
acc.AddQuery(appQ, true);
acc.AddConditionsToLatestCommand(memCmdId);
acc.AddSessionClose();
IDataResult res = acc.Execute("OauthAccess-" + pName);
if (res.GetCommandResultCount(1) == 0)
{
return(null);
}
var om = new OauthMember();
om.Member = res.ToElementAt <Member>(1, 0);
om.AppId = res.ToLongAt(2, 0);
return(om);
}
private void BuildNotify(IOperationData operationData, DynamicObject proxy, InMemoryUser curUser)
{
Type type = proxy.ProxyType;
MethodInfo mi = type.GetMethod(_MethodName);
ParameterInfo pi = mi.GetParameters().First();
object notifyInterface = r.InstanceFromType(pi.ParameterType);
var header = r.InstantiateProperty(notifyInterface, "Header");
r.InstantiateProperty(header, "SenderID", new { Value = SwConstants.ExternalSystemName });
r.SetProperty(notifyInterface, "Header", header);
var rootIntegrationObject = r.InstantiateArrayReturningSingleElement(notifyInterface, "Content");
object integrationObject = r.InstantiateProperty(rootIntegrationObject, 0);
r.SetProperty(integrationObject, "actionSpecified", true);
r.InstantiateProperty(integrationObject, "CHANGEDATE", new { Value = DateTime.Now.FromServerToRightKind() });
//TODO: get current user, in the mobile case below code may be wrong
WsUtil.SetValue(integrationObject, "ORGID", curUser.OrgId);
WsUtil.SetValue(integrationObject, "SITEID", curUser.SiteId);
r.InstantiateProperty(integrationObject, "CHANGEBY", new { Value = curUser.Login });
OperationType operationType = operationData.OperationType;
EntityMetadata metadata = operationData.EntityMetadata;
r.SetProperty(integrationObject, "action", operationType.ToString());
Proxy = proxy;
IntegrationObject = integrationObject;
RootInterfaceObject = notifyInterface;
}
/// <summary>
/// Constructs a InboundBaseStreamWireMessage from the Wire message (Byte segments)
/// </summary>
/// <param name="wireMessage">Wire Message</param>
internal InboundBaseStreamWireMessage(IOperationData wireMessage)
{
// Retreive message header
var wireMessageSegmentEnumerator = wireMessage.GetEnumerator();
var headerExists = wireMessageSegmentEnumerator.MoveNext();
Diagnostics.Assert(headerExists, "InboundStableParameters wire message missing header segment");
this.headerSegment = wireMessageSegmentEnumerator.Current;
// is this the right check regardless of version?
Diagnostics.Assert(this.headerSegment.Count == EncodedByteLength, "Header segment in stream wire message incorrect length");
// Decode Header
this.DecodeHeaderSegment();
// Retreive message payload
var segmentExists = wireMessageSegmentEnumerator.MoveNext();
if (segmentExists)
{
var payloadSegment = wireMessageSegmentEnumerator.Current;
// We rely on the fact that the managed session layer will return a whole byte array not a segment
// The asserts verify that assumption
this.Payload = payloadSegment.Array;
Diagnostics.Assert(payloadSegment.Offset == 0, "Payload segment in inbound session message not whole array");
Diagnostics.Assert(payloadSegment.Count == this.Payload.Length, "Payload segment in inbound session message not whole array");
}
else
{
this.Payload = null;
}
}
unsafe private NativeRuntime.IFabricOperationData CreateNativeOperationData(IOperationData data, uint[] sizes)
{
NativeRuntime.IFabricOperationData operationData = null;
using (var pin = new PinBlittable(sizes))
{
operationData = this.operationDataFactory.CreateOperationData(pin.AddrOfPinnedObject(), (uint)sizes.Length);
}
// get a pointer to the memory that native code allocated in the operation data it created for us
uint countAllocatedByNative;
IntPtr nativeBuffersRaw = operationData.GetData(out countAllocatedByNative);
ReleaseAssert.AssertIfNot(countAllocatedByNative == (uint)sizes.Length, StringResources.Error_BufferNumberMismatach);
NativeTypes.FABRIC_OPERATION_DATA_BUFFER *nativeBuffers = (NativeTypes.FABRIC_OPERATION_DATA_BUFFER *)nativeBuffersRaw;
// copy the data into the buffers allocated by native
int index = 0;
foreach (var item in data)
{
NativeTypes.FABRIC_OPERATION_DATA_BUFFER *nativeBuffer = nativeBuffers + index;
ReleaseAssert.AssertIfNot(nativeBuffer->BufferSize == sizes[index], string.Format(CultureInfo.CurrentCulture, StringResources.Error_BufferAllocationSizeMismatch_Formatted, index, nativeBuffer->BufferSize, sizes[index]));
Marshal.Copy(item.Array, item.Offset, nativeBuffer->Buffer, item.Count);
index++;
}
return(operationData);
}
/*--------------------------------------------------------------------------------------------*/
public OauthMember GetMemberByRefresh(IOperationData pData, string pRefresh)
{
Member path = Weave.Inst.Graph
.V.ExactIndex <OauthAccess>(x => x.Refresh, pRefresh)
.AuthenticatesMember.ToMember;
return(GetOauthMember(pData, path, "GetMemberByRefresh"));
}
/*--------------------------------------------------------------------------------------------*/
public static Member GetMember(IOperationData pData, long pMemId)
{
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, pMemId)
.ToQuery();
return(pData.Get <Member>(q, "Test-OauthLoginGetMember"));
}
public ChunkMaker(IOperationData data)
{
// we only use this in scenarios like inbound messages where data cannot be null
Debug.Assert(data != null);
this.dataSource = data;
this.dataEnumerator = this.dataSource.GetEnumerator();
this.AdvanceEnumerator();
}
/*--------------------------------------------------------------------------------------------*/
public User GetUserByCredentials(IOperationData pData, string pUsername, string pPassword)
{
IWeaverQuery q =
Weave.Inst.Graph
.V.ExactIndex <User>(x => x.NameKey, pUsername.ToLower())
.Has(x => x.Password, WeaverStepHasOp.EqualTo, DataUtil.HashPassword(pPassword))
.ToQuery();
return(pData.Get <User>(q, "OauthLogin-GetUserByCredentials"));
}
/*--------------------------------------------------------------------------------------------*/
public Member GetDataProvMemberByApp(IOperationData pData, long pAppId)
{
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, pAppId)
.DefinesMembers
.Has(x => x.MemberType, WeaverStepHasOp.EqualTo, (byte)MemberType.Id.DataProv)
.ToMember
.ToQuery();
return(pData.Get <Member>(q, "OauthAccess-GetDPMemByApp"));
}
/*--------------------------------------------------------------------------------------------*/
public Member GetMember(IOperationData pData, long pAppId, long pUserId)
{
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <User>(x => x.VertexId, pUserId)
.DefinesMembers
.Has(x => x.AppId, WeaverStepHasOp.EqualTo, pAppId)
.ToMember
.ToQuery();
return(pData.Get <Member>(q, "OauthLogin-GetMember"));
}
bool IMessageMiddleware.Enqueue(IMessage message, IOperationData parms)
{
// process only rabbitmq messages
RabbitMessage m = message as RabbitMessage;
if (m == null)
{
return(false);
}
return(Enqueue(m, parms));
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public App GetApp(IOperationData pData, long pAppId)
{
App app = pData.GetVertexById <App>(pAppId);
if (app == null)
{
throw NewFault(LoginErrors.unauthorized_client, LoginErrorDescs.BadClient);
}
return(app);
}
private long ReplicateBeginWrapper(IOperationData serviceMetadata, IOperationData redoInfo, long sequenceNumberIn, NativeCommon.IFabricAsyncOperationCallback callback, out NativeCommon.IFabricAsyncOperationContext context)
{
long sequenceNumber = sequenceNumberIn;
context = this.nativeStateReplicator.BeginReplicateOperation(
this.GetOrCreateOperationData(serviceMetadata),
this.GetOrCreateOperationData(redoInfo),
callback,
ref sequenceNumber);
return(sequenceNumber);
}
/// <summary>
/// Send message with retry functionality.
/// </summary>
/// <param name="message">message to be sent.</param>
internal void Send(IOperationData message)
{
// TODO: do we need to worry about OutOfMemory exception?
this.sessionQueue.Enqueue(message);
var sessionQuotaExceeded = this.TryDrainSessionSendQueue();
if (sessionQuotaExceeded)
{
Action retryAction = (() => this.QuotaExceededRetry().ContinueWith(this.QuotaExceededRetryContinuation));
Task.Run(retryAction);
}
}
public void Run(IOperationData operationData)
{
var operation = operations
.FirstOrDefault(o => o.CanProcess(operationData));
if (operation == null)
{
throw new NotSupportedException($"Operation '{operationData}' is not supported.");
}
operation.Process(operationData);
}
public MeaExecutionContext(IOperationData operationData, DynamicObject proxy = null)
: base(operationData)
{
if (proxy == null)
{
proxy = DynamicProxyUtil.LookupProxy(operationData.EntityMetadata);
}
// _queryProxy = DynamicProxyUtil.LookupProxy(operationData.EntityMetadata, true);
var curUser = SecurityFacade.CurrentUser();
BuildNotify(operationData, proxy, curUser);
}
public InboundMessage(IOperationData message)
{
this.dataChunks = new ChunkMaker(message);
var segmentCountBuffer = this.dataChunks.GetNextChunk(sizeof(Int32));
this.segmentCount = BitConverter.ToInt32(segmentCountBuffer, 0);
var sizesHeaderBuffer = this.dataChunks.GetNextChunk(this.segmentCount * sizeof(Int32));
Debug.Assert(sizesHeaderBuffer != null);
this.sizesHeader = new SegmentStructureIterator(this.segmentCount, sizesHeaderBuffer);
}
/*--------------------------------------------------------------------------------------------*/
public void DenyScope(IOperationData pData, Member pMember)
{
pMember.OauthScopeAllow = false;
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <Member>(x => x.VertexId, pMember.VertexId)
.SideEffect(
new WeaverStatementSetProperty <Member>(
x => x.OauthScopeAllow, pMember.OauthScopeAllow)
)
.ToQuery();
pData.Execute(q, "OauthLogin-DenyScope");
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public App GetApp(IOperationData pData, long pAppId, string pClientSecret)
{
IWeaverQuery getApp = Weave.Inst.Graph
.V.ExactIndex <App>(x => x.VertexId, pAppId)
.Has(x => x.Secret, WeaverStepHasOp.EqualTo, pClientSecret)
.ToQuery();
App app = pData.Get <App>(getApp, "OauthAccess-GetApp");
if (app == null)
{
throw NewFault(AccessErrors.invalid_client, AccessErrorDescs.BadClientSecret);
}
return(app);
}
public OutboundMessage(IOperationData data)
{
this.data = data;
var sizes = data.Select(elem => elem.Count).ToArray();
var segmentCount = sizes.Length;
this.headerBuffer = new byte[sizeof(Int32) + segmentCount * sizeof(Int32)];
var ms = new MemoryStream(this.headerBuffer);
ms.Write(BitConverter.GetBytes(segmentCount), 0, sizeof(Int32));
foreach (var i in sizes)
{
ms.Write(BitConverter.GetBytes(i), 0, sizeof(Int32));
}
}
public unsafe NativeRuntime.IFabricOperationData CreateOperationData(IOperationData data)
{
if (data == null)
{
return(null);
}
uint[] sizes = data.Select(element => (uint)element.Count).ToArray();
if (sizes.Length == 0)
{
return(null);
}
return(CreateNativeOperationData(data, sizes));
}
/// <summary>
/// May be delayed locally if outbound buffer is full (throttling case)
/// Returns to continuation when the message has been acknowledged as received by the target
/// </summary>
/// <param name="message"></param>
/// <param name="cancellationToken"></param>
public Task SendAsync(IOperationData message, CancellationToken cancellationToken)
{
if (message == null)
{
// TODO: do we support null messages, e.g., for pinging purposes?
throw new ArgumentException(SR.Error_ReliableSession_NullArgument_SendAsync);
}
var sendMessage = new ReliableSessionMessage(new OutboundMessage(message));
//TODO: what if sendMessage is null?
return(Utility.WrapNativeAsyncInvokeInMTA(
(callback) => this.SendBeginWrapper(sendMessage, callback),
(context) => this.SendEndWrapper(sendMessage, context),
cancellationToken,
"ReliableSession.SendAsync"));
}
private NativeRuntime.IFabricOperationData GetOrCreateOperationData(IOperationData operationData)
{
OperationData managed = operationData as OperationData;
if (managed != null)
{
return(this.operationDataFactory.CreateOperationData(managed));
}
ReadOnlyOperationData native = operationData as ReadOnlyOperationData;
if (native != null)
{
return(native.NativeOperationData);
}
return(null);
}
public MifExecutionContext(IOperationData operationData, DynamicObject proxy = null)
: base(operationData)
{
Proxy = proxy ?? DynamicProxyUtil.LookupProxy(operationData.EntityMetadata);
CheckCredentials(Proxy);
var curUser = SecurityFacade.CurrentUser();
var operationType = operationData.OperationType;
var isCreation = OperationType.Add == operationType;
_methodName = MifMethodNameUtils.GetMethodName(Metadata, operationType);
var type = Proxy.ProxyType;
var mi = type.GetMethod(_methodName);
var pi = mi.GetParameters().First();
// element array , like MXSW3_WO_TYPE[]
var parameterType = pi.ParameterType;
object notifyInterface;
object integrationObject;
if (parameterType.IsArray)
{
notifyInterface = ReflectionUtil.InstantiateArrayWithBlankElements(parameterType.GetElementType(), 1);
integrationObject = ((Array)notifyInterface).GetValue(0);
}
else
{
notifyInterface = ReflectionUtil.InstanceFromType(parameterType);
integrationObject = notifyInterface;
}
r.SetProperty(integrationObject, "actionSpecified", true);
r.InstantiateProperty(integrationObject, "CHANGEDATE", new { Value = DateTime.Now.FromServerToRightKind() });
//TODO: get current user, in the mobile case below code may be wrong
r.InstantiateProperty(integrationObject, "CHANGEBY", new { Value = curUser.Login });
//TODO: get from user
r.InstantiateProperty(integrationObject, "ORGID", new { Value = curUser.OrgId });
r.InstantiateProperty(integrationObject, "SITEID", new { Value = curUser.SiteId });
r.SetProperty(integrationObject, "action", operationType.ToString());
IntegrationObject = integrationObject;
RootInterfaceObject = notifyInterface;
}
////////////////////////////////////////////////////////////////////////////////////////////////
/*--------------------------------------------------------------------------------------------*/
public OauthAccess GetAccessToken(IOperationData pData, string pToken)
{
if (pToken == null || pToken.Length != 32)
{
throw NewFault(LogoutErrors.invalid_request, LogoutErrorDescs.BadToken);
}
IWeaverQuery q = Weave.Inst.Graph
.V.ExactIndex <OauthAccess>(x => x.Token, pToken)
.ToQuery();
OauthAccess oa = pData.Get <OauthAccess>(q, "OauthLogout-GetAccessToken");
if (oa == null)
{
throw NewFault(LogoutErrors.invalid_request, LogoutErrorDescs.NoTokenMatch);
}
return(oa);
}
public Task <long> ReplicateOperationAsync(IOperationData serviceMetadata, IOperationData redoInfo, CancellationToken cancellationToken, ref long sequenceNumber)
{
Requires.Argument("redoInfo", redoInfo).NotNull();
long sequenceNumberOut = sequenceNumber;
var task = Utility.WrapNativeAsyncInvoke <long>(
(callback) =>
{
NativeCommon.IFabricAsyncOperationContext context;
sequenceNumberOut = this.ReplicateBeginWrapper(serviceMetadata, redoInfo, sequenceNumberOut, callback, out context);
return(context);
},
this.ReplicateEndWrapper,
cancellationToken,
"AtomicGroupStateReplicatorEx.ReplicateAsync");
sequenceNumber = sequenceNumberOut;
return(task);
}
public void SetUp()
{
vMockAcc = MockDataAccess.Create(mda => {
MockDataAccessCmd cmd = mda.GetCommand(0);
Assert.AreEqual(BasicScript + ";", cmd.Script, "Incorrect Query.Script.");
TestUtil.CheckParams(cmd.Params, "_P", new List <object>());
});
vMockFact = new Mock <IDataAccessFactory>(MockBehavior.Strict);
vMockFact.Setup(x => x.Create(null, false, true)).Returns(vMockAcc.Object);
vMockMet = new Mock <IMetricsManager>(MockBehavior.Strict);
vMockMet.Setup(x => x.Counter(It.IsAny <string>(), It.IsAny <long>()));
vMockMet.Setup(x => x.Timer(It.IsAny <string>(), It.IsAny <long>()));
vMockMet.Setup(x => x.Mean(It.IsAny <string>(), It.IsAny <long>()));
vMockCache = new Mock <IMemCache>(MockBehavior.Strict);
vData = new OperationData(new Guid(), vMockFact.Object, vMockMet.Object, vMockCache.Object);
vBasicQuery = new WeaverQuery();
vBasicQuery.FinalizeQuery(BasicScript);
}
