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); }