internal void InternalInvokeAsync(IMessageSink ar, Message reqMsg, bool useDispatchMessage, int callType) { Identity identityObject = this.IdentityObject; ServerIdentity serverIdentity = identityObject as ServerIdentity; MethodCall methodCall = new MethodCall((IMessage)reqMsg); IInternalMessage internalMessage = (IInternalMessage)methodCall; internalMessage.IdentityObject = identityObject; if (serverIdentity != null) { internalMessage.ServerIdentityObject = serverIdentity; } if (useDispatchMessage) { ChannelServices.AsyncDispatchMessage((IMessage)methodCall, (callType & 8) != 0 ? (IMessageSink)null : ar); } else { if (identityObject.EnvoyChain == null) { throw new InvalidOperationException(Environment.GetResourceString("Remoting_Proxy_InvalidState")); } identityObject.EnvoyChain.AsyncProcessMessage((IMessage)methodCall, (callType & 8) != 0 ? (IMessageSink)null : ar); } if ((callType & 1) == 0 || (callType & 8) == 0) { return; } ar.SyncProcessMessage((IMessage)null); }
private object[] WriteMethodCall(IMethodCallMessage mcm) { string uri = mcm.Uri; string methodName = mcm.MethodName; string typeName = mcm.TypeName; object methodSignature = (object)null; object[] properties = (object[])null; Type[] instArgs = (Type[])null; if (mcm.MethodBase.IsGenericMethod) { instArgs = mcm.MethodBase.GetGenericArguments(); } object[] args = mcm.Args; IInternalMessage internalMessage = mcm as IInternalMessage; if (internalMessage == null || internalMessage.HasProperties()) { properties = ObjectWriter.StoreUserPropertiesForMethodMessage((IMethodMessage)mcm); } if (mcm.MethodSignature != null && RemotingServices.IsMethodOverloaded((IMethodMessage)mcm)) { methodSignature = mcm.MethodSignature; } LogicalCallContext logicalCallContext = mcm.LogicalCallContext; object callContext = logicalCallContext != null ? (!logicalCallContext.HasInfo ? (object)logicalCallContext.RemotingData.LogicalCallID : (object)logicalCallContext) : (object)null; return(this.serWriter.WriteCallArray(uri, methodName, typeName, instArgs, args, methodSignature, callContext, properties)); }
protected override void Beat() { IInternalMessage message = SystemMessageQueue.Instance.Poll(); if (message != null) { switch (message.GetMessageId()) { case AsyncTaskMessage.ASYNC_MESSAGE_ID: { AsyncTaskMessage asyncTaskMessage = message as AsyncTaskMessage; AsyncState state = asyncTaskMessage.State; IAsyncTask asyncTask = asyncTaskMessage.AsyncTask; if (state == AsyncState.DoAsync) { throw new ApplicationException(string.Format("asyncTask:{0} [DoAsyncTask] infinite loop.", asyncTask.GetType().FullName)); } AsyncManager.Instance.ExecuteAsyncTask(state, asyncTask); break; } default: { break; } } } }
/// <summary> /// 将一个系统消息加入到队列中 /// </summary> /// <param name="internalMessage">系统消息对象</param> public void Offer(IInternalMessage internalMessage) { lock (this) { messageQueue.Enqueue(internalMessage); } }
// This check if the call-site on the TP is in our own AD // It also handles the special case where the TP is on // a well-known object and we cannot do stack-blting internal bool IsOKToStackBlt(IMethodMessage mcMsg, Object server) { bool bOK = false; Message msg = mcMsg as Message; if (null != msg) { IInternalMessage iiMsg = (IInternalMessage)msg; // If there is a frame in the message we can always // Blt it (provided it is not a proxy to a well-known // object in our own appDomain)! // The GetThisPtr == server test allows for people to wrap // our proxy with their own interception .. in that case // we should not blt the stack. if (msg.GetFramePtr() != IntPtr.Zero && msg.GetThisPtr() == server && (iiMsg.IdentityObject == null || (iiMsg.IdentityObject != null && iiMsg.IdentityObject == iiMsg.ServerIdentityObject ) ) ) { bOK = true; } } return(bOK); }
// This is called from InternalInvoke above when someone makes an // Async (or a one way) call on a TP internal void InternalInvokeAsync(IMessageSink ar, Message reqMsg, bool useDispatchMessage, int callType) { IMessageCtrl cc = null; Identity idObj = IdentityObject; ServerIdentity serverID = idObj as ServerIdentity; MethodCall cpyMsg = new MethodCall(reqMsg); IInternalMessage iim = ((IInternalMessage)cpyMsg); // Set the identity in the message object iim.IdentityObject = idObj; if (null != serverID) { Message.DebugOut("Setting SrvID on deser msg\n"); iim.ServerIdentityObject = serverID; } if (useDispatchMessage) { Message.DebugOut( "RemotingProxy.Invoke: Calling AsyncDispatchMessage\n"); BCLDebug.Assert(ar != null, "ar != null"); BCLDebug.Assert((callType & Message.BeginAsync) != 0, "BeginAsync flag not set!"); Message.DebugOut("Calling AsynDispatchMessage \n"); cc = ChannelServices.AsyncDispatchMessage( cpyMsg, ((callType & Message.OneWay) != 0) ? null : ar); } else if (null != idObj.EnvoyChain) { Message.DebugOut("RemotingProxy.Invoke: Calling AsyncProcessMsg on the envoy chain\n"); cc = idObj.EnvoyChain.AsyncProcessMessage( cpyMsg, ((callType & Message.OneWay) != 0) ? null : ar); } else { // Channel sink cannot be null since it is the last sink in // the client context // Assert if Invoke is called without a channel sink BCLDebug.Assert(false, "How did we get here?"); throw new InvalidOperationException( Environment.GetResourceString("Remoting_Proxy_InvalidState")); } if ((callType & Message.BeginAsync) != 0) { if ((callType & Message.OneWay) != 0) { ar.SyncProcessMessage(null); } } }
internal static ServerIdentity GetServerIdentity(IMessage reqMsg) { ServerIdentity serverIdentityObject = null; bool flag = false; IInternalMessage message = reqMsg as IInternalMessage; if (message != null) { serverIdentityObject = ((IInternalMessage)reqMsg).ServerIdentityObject; flag = true; } else if (reqMsg is InternalMessageWrapper) { serverIdentityObject = (ServerIdentity)((InternalMessageWrapper)reqMsg).GetServerIdentityObject(); } if (serverIdentityObject == null) { Identity identity2 = IdentityHolder.ResolveIdentity(GetURI(reqMsg)); if (identity2 is ServerIdentity) { serverIdentityObject = (ServerIdentity)identity2; if (flag) { message.ServerIdentityObject = serverIdentityObject; } } } return(serverIdentityObject); }
internal void InternalInvokeAsync(IMessageSink ar, Message reqMsg, bool useDispatchMessage, int callType) { Identity identityObject = this.IdentityObject; ServerIdentity identity2 = identityObject as ServerIdentity; MethodCall msg = new MethodCall(reqMsg); IInternalMessage message = msg; message.IdentityObject = identityObject; if (identity2 != null) { message.ServerIdentityObject = identity2; } if (useDispatchMessage) { ChannelServices.AsyncDispatchMessage(msg, ((callType & 8) != 0) ? null : ar); } else { if (identityObject.EnvoyChain == null) { throw new InvalidOperationException(Environment.GetResourceString("Remoting_Proxy_InvalidState")); } identityObject.EnvoyChain.AsyncProcessMessage(msg, ((callType & 8) != 0) ? null : ar); } if (((callType & 1) != 0) && ((callType & 8) != 0)) { ar.SyncProcessMessage(null); } }
internal static ServerIdentity GetServerIdentity(IMessage reqMsg) { ServerIdentity serverIdentity = null; bool flag = false; IInternalMessage internalMessage = reqMsg as IInternalMessage; if (internalMessage != null) { serverIdentity = ((IInternalMessage)reqMsg).ServerIdentityObject; flag = true; } else if (reqMsg is InternalMessageWrapper) { serverIdentity = (ServerIdentity)((InternalMessageWrapper)reqMsg).GetServerIdentityObject(); } if (serverIdentity == null) { string uri = InternalSink.GetURI(reqMsg); Identity identity = IdentityHolder.ResolveIdentity(uri); if (identity is ServerIdentity) { serverIdentity = (ServerIdentity)identity; if (flag) { internalMessage.ServerIdentityObject = serverIdentity; } } } return(serverIdentity); }
private SmuggledMethodCallMessage(IMethodCallMessage mcm) { this._uri = mcm.Uri; this._methodName = mcm.MethodName; this._typeName = mcm.TypeName; ArrayList arrayList = null; IInternalMessage internalMessage = mcm as IInternalMessage; if (internalMessage == null || internalMessage.HasProperties()) { this._propertyCount = MessageSmuggler.StoreUserPropertiesForMethodMessage(mcm, ref arrayList); } if (mcm.MethodBase.IsGenericMethod) { Type[] genericArguments = mcm.MethodBase.GetGenericArguments(); if (genericArguments != null && genericArguments.Length != 0) { if (arrayList == null) { arrayList = new ArrayList(); } this._instantiation = new MessageSmuggler.SerializedArg(arrayList.Count); arrayList.Add(genericArguments); } } if (RemotingServices.IsMethodOverloaded(mcm)) { if (arrayList == null) { arrayList = new ArrayList(); } this._methodSignature = new MessageSmuggler.SerializedArg(arrayList.Count); arrayList.Add(mcm.MethodSignature); } LogicalCallContext logicalCallContext = mcm.LogicalCallContext; if (logicalCallContext == null) { this._callContext = null; } else if (logicalCallContext.HasInfo) { if (arrayList == null) { arrayList = new ArrayList(); } this._callContext = new MessageSmuggler.SerializedArg(arrayList.Count); arrayList.Add(logicalCallContext); } else { this._callContext = logicalCallContext.RemotingData.LogicalCallID; } this._args = MessageSmuggler.FixupArgs(mcm.Args, ref arrayList); if (arrayList != null) { MemoryStream memoryStream = CrossAppDomainSerializer.SerializeMessageParts(arrayList); this._serializedArgs = memoryStream.GetBuffer(); } }
private void MessageProvider_Received(object sender, IInternalMessage e) { switch (e) { case T1 t1: { if (_siteOptions.IsIgnore50Counts && int.TryParse(t1.Cm, out int count)) { if (count >= 1 && count <= 50) { //1-50の数字のみのコメントは無視する return; } } var message = new ShowRoomComment(t1); var userId = message.UserId; var isFirstComment = _first.IsFirstComment(userId); var user = GetUser(userId); user.Name = message.NameItems; var metadata = CreateMessageMetadata(message, user, isFirstComment); var methods = new MessageMethods(); RaiseMessageReceived(new MessageContext(message, metadata, methods)); } break; } }
private SmuggledMethodCallMessage(IMethodCallMessage mcm) { _uri = mcm.Uri; _methodName = mcm.MethodName; _typeName = mcm.TypeName; ArrayList argsToSerialize = null; IInternalMessage iim = mcm as IInternalMessage; // user properties (everything but special entries) if ((iim == null) || iim.HasProperties()) { _propertyCount = StoreUserPropertiesForMethodMessage(mcm, ref argsToSerialize); } // handle method signature if (RemotingServices.IsMethodOverloaded(mcm)) { if (argsToSerialize == null) { argsToSerialize = new ArrayList(); } _methodSignature = new SerializedArg(argsToSerialize.Count); argsToSerialize.Add(mcm.MethodSignature); } // handle call context LogicalCallContext lcc = mcm.LogicalCallContext; if (lcc == null) { _callContext = null; } else if (lcc.HasInfo) { if (argsToSerialize == null) { argsToSerialize = new ArrayList(); } _callContext = new SerializedArg(argsToSerialize.Count); argsToSerialize.Add(lcc); } else { // just smuggle the call id string _callContext = lcc.RemotingData.LogicalCallID; } _args = FixupArgs(mcm.Args, ref argsToSerialize); if (argsToSerialize != null) { //MemoryStream argStm = CrossAppDomainSerializer.SerializeMessageParts(argsToSerialize, out _serializerSmuggledArgs); MemoryStream argStm = CrossAppDomainSerializer.SerializeMessageParts(argsToSerialize); _serializedArgs = argStm.GetBuffer(); } } // SmuggledMethodCallMessage
public void Send(IInternalMessage message) { if (message is MethodBase method) { _methodReplyDict.AddOrUpdate(method.Id, method, (n, t) => t); } _webSocket.Send(message.Raw); }
public override IMessage Invoke(IMessage request) { IMethodCallMessage methodCallMessage = request as IMethodCallMessage; if (methodCallMessage != null) { if (methodCallMessage.MethodBase == RemotingProxy._cache_GetHashCodeMethod) { return(new MethodResponse(base.ObjectIdentity.GetHashCode(), null, null, methodCallMessage)); } if (methodCallMessage.MethodBase == RemotingProxy._cache_GetTypeMethod) { return(new MethodResponse(base.GetProxiedType(), null, null, methodCallMessage)); } } IInternalMessage internalMessage = request as IInternalMessage; if (internalMessage != null) { if (internalMessage.Uri == null) { internalMessage.Uri = this._targetUri; } internalMessage.TargetIdentity = this._objectIdentity; } this._objectIdentity.NotifyClientDynamicSinks(true, request, true, false); IMessageSink messageSink; if (Thread.CurrentContext.HasExitSinks && !this._hasEnvoySink) { messageSink = Thread.CurrentContext.GetClientContextSinkChain(); } else { messageSink = this._sink; } MonoMethodMessage monoMethodMessage = request as MonoMethodMessage; IMessage result; if (monoMethodMessage == null || monoMethodMessage.CallType == CallType.Sync) { result = messageSink.SyncProcessMessage(request); } else { AsyncResult asyncResult = monoMethodMessage.AsyncResult; IMessageCtrl messageCtrl = messageSink.AsyncProcessMessage(request, asyncResult); if (asyncResult != null) { asyncResult.SetMessageCtrl(messageCtrl); } result = new ReturnMessage(null, new object[0], 0, null, monoMethodMessage); } this._objectIdentity.NotifyClientDynamicSinks(false, request, true, false); return(result); }
internal bool IsOKToStackBlt(IMethodMessage mcMsg, object server) { bool result = false; Message message = mcMsg as Message; if (message != null) { IInternalMessage internalMessage = message; if (message.GetFramePtr() != IntPtr.Zero && message.GetThisPtr() == server && (internalMessage.IdentityObject == null || (internalMessage.IdentityObject != null && internalMessage.IdentityObject == internalMessage.ServerIdentityObject))) { result = true; } } return(result); }
private void MetaProvider_MessageReceived(object sender, IInternalMessage e) { switch (e) { case ICurrentRoom currentRoom: { //currentRoom.MessageServerUri _messageUrl = currentRoom.MessageServerUri; _threadId = currentRoom.ThreadId; _roomName = currentRoom.RoomName; _tcs.SetResult(null); } break; } }
private void P1_MessageReceived(object sender, IInternalMessage e) { var internalMessage = e; switch (internalMessage) { case InternalComment comment: { _lastCommentId = comment.Id; var context = CreateMessageContext(comment, false); RaiseMessageReceived(context); } break; } }
internal object GetServerIdentityObject() { IInternalMessage internalMessage = this.WrappedMessage as IInternalMessage; if (internalMessage != null) { return(internalMessage.ServerIdentityObject); } InternalMessageWrapper internalMessageWrapper = this.WrappedMessage as InternalMessageWrapper; if (internalMessageWrapper != null) { return(internalMessageWrapper.GetServerIdentityObject()); } return(null); }
internal object GetIdentityObject() { IInternalMessage wrappedMessage = this.WrappedMessage as IInternalMessage; if (wrappedMessage != null) { return(wrappedMessage.IdentityObject); } InternalMessageWrapper wrapper = this.WrappedMessage as InternalMessageWrapper; if (wrapper != null) { return(wrapper.GetIdentityObject()); } return(null); }
public void SetMessage(IInternalMessage internalMessage) { if (internalMessage is EnterRoom) { _isBeeingSentInitialComments = true; } else if (_isBeeingSentInitialComments && !(internalMessage is OnChatMessage)) { _isBeeingSentInitialComments = false; } var messageContext = CreateMessageContext(internalMessage); if (messageContext != null) { RaiseMessageReceived(messageContext); } }
internal bool IsOKToStackBlt(IMethodMessage mcMsg, object server) { bool flag = false; Message message = mcMsg as Message; if (message == null) { return(flag); } IInternalMessage message2 = message; if ((!(message.GetFramePtr() != IntPtr.Zero) || (message.GetThisPtr() != server)) || ((message2.IdentityObject != null) && ((message2.IdentityObject == null) || (message2.IdentityObject != message2.ServerIdentityObject)))) { return(flag); } return(true); }
private void P1_MessageReceived(object sender, IInternalMessage e) { if (e is Kind1Type1 kind1Type1) { var message = new PeriscopeComment(kind1Type1); var userId = message.UserId; var isFirstComment = _first.IsFirstComment(userId); var user = GetUser(userId); user.Name = MessagePartFactory.CreateMessageItems(message.Text); var metadata = CreateMessageMetadata(message, user, isFirstComment); var methods = new MessageMethods(); RaiseMessageReceived(new MessageContext(message, metadata, methods)); } else if (e is Kind2Kind1 kind2kind1) { if (!_siteOptions.IsShowJoinMessage) { //取得する必要がないため無視する return; } var message = new PeriscopeJoin(kind2kind1); var userId = message.UserId; var isFirstComment = false; var user = GetUser(userId); user.Name = MessagePartFactory.CreateMessageItems(message.DisplayName); var metadata = CreateMessageMetadata(message, user, isFirstComment); var methods = new MessageMethods(); RaiseMessageReceived(new MessageContext(message, metadata, methods)); } else if (e is Kind2Kind2 kind2Kind2) { if (!_siteOptions.IsShowLeaveMessage) { //取得する必要がないため無視する return; } var message = new PeriscopeLeave(kind2Kind2); var userId = message.UserId; var isFirstComment = false; var user = GetUser(userId); user.Name = MessagePartFactory.CreateMessageItems(message.DisplayName); var metadata = CreateMessageMetadata(message, user, isFirstComment); var methods = new MessageMethods(); RaiseMessageReceived(new MessageContext(message, metadata, methods)); } }
public override async void SetMessage(string rawMessage) { IInternalMessage internalMessage = null; try { internalMessage = MessageParser.Parse(rawMessage, _imageDict); } catch (Exception ex) { _logger.LogException(ex, "", $"raw={rawMessage}"); } if (internalMessage == null) { SendSystemInfo($"ParseError: {rawMessage}", InfoType.Error); return; } SetMessage(internalMessage); }
internal void PropagateIncomingHeadersToCallContext(IMessage msg) { IInternalMessage internalMessage = msg as IInternalMessage; if (internalMessage != null && !internalMessage.HasProperties()) { return; } IDictionary properties = msg.Properties; IDictionaryEnumerator enumerator = properties.GetEnumerator(); int num = 0; while (enumerator.MoveNext()) { string text = (string)enumerator.Key; if (!text.StartsWith("__", StringComparison.Ordinal) && enumerator.Value is Header) { num++; } } Header[] array = null; if (num > 0) { array = new Header[num]; num = 0; enumerator.Reset(); while (enumerator.MoveNext()) { string text2 = (string)enumerator.Key; if (!text2.StartsWith("__", StringComparison.Ordinal)) { Header header = enumerator.Value as Header; if (header != null) { array[num++] = header; } } } } this._recvHeaders = array; this._sendHeaders = null; }
private void ProcessAction(IInternalMessage action) { switch (action) { case InternalComment comment: MessageReceived?.Invoke(this, comment); break; case InternalSuperChat superChat: MessageReceived?.Invoke(this, superChat); break; case InternalMembership membership: MessageReceived?.Invoke(this, membership); break; default: break; } }
private object[] WriteMethodCall(IMethodCallMessage mcm) { string uri = mcm.Uri; string methodName = mcm.MethodName; string typeName = mcm.TypeName; object methodSignature = null; object callContext = null; object[] properties = null; Type[] instArgs = null; if (mcm.MethodBase.IsGenericMethod) { instArgs = mcm.MethodBase.GetGenericArguments(); } object[] args = mcm.Args; IInternalMessage message = mcm as IInternalMessage; if ((message == null) || message.HasProperties()) { properties = StoreUserPropertiesForMethodMessage(mcm); } if ((mcm.MethodSignature != null) && RemotingServices.IsMethodOverloaded(mcm)) { methodSignature = mcm.MethodSignature; } LogicalCallContext logicalCallContext = mcm.LogicalCallContext; if (logicalCallContext == null) { callContext = null; } else if (logicalCallContext.HasInfo) { callContext = logicalCallContext; } else { callContext = logicalCallContext.RemotingData.LogicalCallID; } return(this.serWriter.WriteCallArray(uri, methodName, typeName, instArgs, args, methodSignature, callContext, properties)); }
private void P1_MessageReceived(object sender, IInternalMessage e) { var internalMessage = e; switch (internalMessage) { case ChatMessageData chat: var context = CreateMessageContext(chat); RaiseMessageReceived(context); break; case UserUpdateEvent userUpdate: break; case DeleteMessageEvent deleteMessage: break; default: break; } }
[System.Security.SecurityCritical] // auto-generated internal static ServerIdentity GetServerIdentity(IMessage reqMsg) { ServerIdentity srvID = null; bool bOurMsg = false; String objURI = null; IInternalMessage iim = reqMsg as IInternalMessage; if (iim != null) { Message.DebugOut("GetServerIdentity.ServerIdentity from IInternalMessage\n"); srvID = ((IInternalMessage)reqMsg).ServerIdentityObject; bOurMsg = true; } else if (reqMsg is InternalMessageWrapper) { srvID = (ServerIdentity)((InternalMessageWrapper)reqMsg).GetServerIdentityObject(); } // Try the slow path if the identity has not been obtained yet if (null == srvID) { Message.DebugOut("GetServerIdentity.ServerIdentity from IMethodCallMessage\n"); objURI = GetURI(reqMsg); Identity id = IdentityHolder.ResolveIdentity(objURI); if (id is ServerIdentity) { srvID = (ServerIdentity)id; // Cache the serverIdentity in the message if (bOurMsg) { iim.ServerIdentityObject = srvID; } } } return(srvID); }
public async Task Publish(IInternalMessage message) { Type incomingMessageType = message.GetType(); KeyValuePair <Type, Dictionary <object, Subscriber> >[] typesAndSubscribersArr = null; lock (typesAndSubscribers) { typesAndSubscribersArr = typesAndSubscribers.ToArray(); } foreach (KeyValuePair <Type, Dictionary <object, Subscriber> > typesAndSubs in typesAndSubscribersArr) { Type type = typesAndSubs.Key; if (incomingMessageType.Is(type)) { KeyValuePair <object, Subscriber>[] subscribersArr = null; lock (typesAndSubscribers) { subscribersArr = typesAndSubs.Value.ToArray(); } foreach (KeyValuePair <object, Subscriber> subscriber in subscribersArr) { Func <IInternalMessage, Task>[] actionsArr = null; lock (typesAndSubscribers) { actionsArr = subscriber.Value.Actions.ToArray(); } foreach (Func <IInternalMessage, Task> action in actionsArr) { await action(message); } } } } }
internal void PropagateIncomingHeadersToCallContext(IMessage msg) { IInternalMessage message = msg as IInternalMessage; if ((message == null) || message.HasProperties()) { IDictionaryEnumerator enumerator = msg.Properties.GetEnumerator(); int num = 0; while (enumerator.MoveNext()) { string key = (string)enumerator.Key; if (!key.StartsWith("__", StringComparison.Ordinal) && (enumerator.Value is Header)) { num++; } } Header[] headerArray = null; if (num > 0) { headerArray = new Header[num]; num = 0; enumerator.Reset(); while (enumerator.MoveNext()) { string str2 = (string)enumerator.Key; if (!str2.StartsWith("__", StringComparison.Ordinal)) { Header header = enumerator.Value as Header; if (header != null) { headerArray[num++] = header; } } } } this._recvHeaders = headerArray; this._sendHeaders = null; } }