/// <summary> /// Constructs an instance of the SharedMemoryConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public SharedMemoryConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this._sendTimeoutSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.SMSendTimeout]); this.Local = new HostInformation("_gshmem://" + iTransportContext.HostIdentifier, iTransportContext); TimerProvider.Attach(this); }
/// <summary> /// Constructs an instance of the UdpConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public UdpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this.Local = new HostInformation("_gudp://" + iTransportContext.HostIdentifier, iTransportContext); this._sendBuffer = new byte[(int)iTransportContext.IParameterProvider[GenuineParameter.UdpPacketSize]]; TimerProvider.Attach(this); this._closeInvocationConnectionAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.CloseInvocationConnectionAfterInactivity]); }
/// <summary> /// Makes message up from the IMessage. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="iMessage">IMessage to make the message up from.</param> /// <param name="iTransportHeaders">Trasport headers.</param> /// <param name="stream">Message body.</param> /// <param name="isSynchronous">True if the invocation is synchronous.</param> /// <returns>An instance of the Message class.</returns> public static Message CreateOutcomingMessage(ITransportContext iTransportContext, IMessage iMessage, ITransportHeaders iTransportHeaders, Stream stream, bool isSynchronous) { // when microsoft guys start caring about detailed .NET remoting documentation??? string url = (string)iMessage.Properties["__Uri"]; string objectURI; string channelUri = GenuineUtility.Parse(url, out objectURI); if (objectURI == null) { objectURI = url; // not well-known object } iTransportHeaders[TransportHeaderName_RemoteObjectUri] = objectURI; Message message = new Message(iTransportContext, null, 0, iTransportHeaders, stream); message.IMessage = iMessage; message.IsSynchronous = isSynchronous; if (iTransportHeaders[Message.TransportHeadersGenuineMessageType] != null) { message.GenuineMessageType = (GenuineMessageType)iTransportHeaders[Message.TransportHeadersGenuineMessageType]; } return(message); }
/// <summary> /// Constructs an instance of the SMAcceptConnectionClosure class. /// </summary> /// <param name="iTransportContext">The transport context.</param> /// <param name="sharedMemoryConnection">The server's connection.</param> /// <param name="sharedMemoryConnectionManager">The connection manager.</param> /// <param name="shareName">The name of the share.</param> public SMAcceptConnectionClosure(ITransportContext iTransportContext, SharedMemoryConnection sharedMemoryConnection, SharedMemoryConnectionManager sharedMemoryConnectionManager, string shareName) { this.ITransportContext = iTransportContext; this.SharedMemoryConnection = sharedMemoryConnection; this.SharedMemoryConnectionManager = sharedMemoryConnectionManager; this.ShareName = shareName; }
/// <summary> /// Constructs an instance of the AcceptConnectionClosure class. /// </summary> /// <param name="iTransportContext">The transport context.</param> /// <param name="listeningEndPoint">The end point.</param> /// <param name="socket">The socket.</param> /// <param name="iAcceptConnectionConsumer"></param> public AcceptConnectionClosure(ITransportContext iTransportContext, string listeningEndPoint, Socket socket, IAcceptConnectionConsumer iAcceptConnectionConsumer) { this.ITransportContext = iTransportContext; this.ListeningEndPoint = listeningEndPoint; this.Socket = socket; this.IAcceptConnectionConsumer = iAcceptConnectionConsumer; }
/// <summary> /// Constructs an instance of the UdpConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public UdpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this.Local = new HostInformation("_gudp://" + iTransportContext.HostIdentifier, iTransportContext); this._sendBuffer = new byte[(int) iTransportContext.IParameterProvider[GenuineParameter.UdpPacketSize]]; TimerProvider.Attach(this); this._closeInvocationConnectionAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.CloseInvocationConnectionAfterInactivity]); }
public AmqpConnection(AmqpProvider provider, ITransportContext transport, ConnectionInfo info) { this.Provider = provider; this.transport = transport; this.remoteUri = provider.RemoteUri; this.Info = info; this.messageFactory = new AmqpMessageFactory(this); }
/// <summary> /// Constructs an instance of the MessageContainer class. /// </summary> public MessageContainer(ITransportContext iTransportContext) { this._iTransportContext = iTransportContext; this._maxQueuedItems = (int)iTransportContext.IParameterProvider[GenuineParameter.MaxQueuedItems]; this._maxTotalSize = (int)iTransportContext.IParameterProvider[GenuineParameter.MaxTotalSize]; this._maxContentSize = (int)iTransportContext.IParameterProvider[GenuineParameter.MaxContentSize]; this._noSizeChecking = (bool)iTransportContext.IParameterProvider[GenuineParameter.NoSizeChecking]; }
public IProvider CreateProvider(Uri remoteUri) { ITransportContext transportContext = TransportContextFactory.CreateTransportContext(remoteUri); AmqpProvider amqpProvider = new AmqpProvider(remoteUri, transportContext); StringDictionary properties = URISupport.ParseQuery(remoteUri.Query); StringDictionary filteredProperties = PropertyUtil.FilterProperties(properties, "amqp."); PropertyUtil.SetProperties(amqpProvider, filteredProperties); return amqpProvider; }
/// <summary> /// Constructs an instance of the HostInformation class. /// Instances of the class HostInformation must be constructed only by objects implementing /// the IKnownHosts interface. /// </summary> /// <param name="uriOrUrl">Uri or Url of the remote host.</param> /// <param name="iTransportContext">Transport Context.</param> internal HostInformation(string uriOrUrl, ITransportContext iTransportContext) { this._iTransportContext = iTransportContext; if (uriOrUrl[0] == '_') { this._uri = uriOrUrl; UriStorage.RegisterConnection(uriOrUrl, this.ITransportContext); } else this._url = uriOrUrl; }
public static ITransportContext CreateTransportContext(Uri uri) { ITransportContext transportContext = uri.Scheme.ToUpper().Equals("AMQPS") ? new SecureTransportContext() : new TransportContext(); StringDictionary properties = URISupport.ParseQuery(uri.Query); StringDictionary filteredProperties = PropertyUtil.FilterProperties(properties, "transport."); PropertyUtil.SetProperties(transportContext, filteredProperties); return(transportContext); }
/// <summary> /// Gets a Transport Context responsible for the connection to the specified remoteUri. /// </summary> /// <param name="remoteUri">The uri of the remote host.</param> /// <returns>Transport Context or a null reference.</returns> public static ITransportContext GetTransportContext(string remoteUri) { ITransportContext iTransportContext = null; WeakReference weakReference = _knownUris[remoteUri] as WeakReference; if (weakReference != null) { iTransportContext = weakReference.Target as ITransportContext; } return(iTransportContext); }
/// <summary> /// Constructs the instance of the LabelledStream class. /// </summary> /// <param name="iTransportContext">The transport context.</param> /// <param name="underlyingStream">The source stream containing labelled content.</param> /// <param name="intermediateBuffer">The intermediate buffer.</param> public LabelledStream(ITransportContext iTransportContext, Stream underlyingStream, byte[] intermediateBuffer) { this.ITransportContext = iTransportContext; this._underlyingStream = underlyingStream; this._readBuffer = intermediateBuffer; this._validLength = 0; this._currentPosition = 0; this._currentPacketSize = 0; this._currentPacketBytesRead = 0; this._messageRead = false; }
/// <summary> /// Constructs an instance of the TcpSocketInfo class. /// </summary> /// <param name="socket">The socket.</param> /// <param name="iTransportContext">Transport Context.</param> /// <param name="connectionName">The name of the connection.</param> internal TcpSocketInfo(Socket socket, ITransportContext iTransportContext, string connectionName) #endif { this.Socket = socket; this.ITransportContext = iTransportContext; this.ConnectionName = connectionName == null ? "~" + Guid.NewGuid().ToString("N") : connectionName; this.MaxSendSize = (int)this.ITransportContext.IParameterProvider[GenuineParameter.TcpMaxSendSize]; #if DEBUG this._typeOfSocket = typeOfSocket; this._connectionNumber = Interlocked.Increment(ref _dbg_ConnectionCounter); #endif }
/// <summary> /// Constructs an instance of the GenuineTcpClientTransportSink class. /// </summary> /// <param name="url">The Url of the remote object.</param> /// <param name="iTransportContext">The transport context.</param> public GenuineTcpClientTransportSink(string url, ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; string objectURI; this._recipientUri = GenuineUtility.Parse(url, out objectURI); this._properties["GC_URI"] = this._recipientUri; this._properties["GC_TC"] = iTransportContext; // it's rather a trick, but works well this._properties["GC_TS"] = this; }
/// <summary> /// Constructs an instance of the HttpServerConnection class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="hostId">The id of the remote host.</param> /// <param name="remote">The remote host.</param> /// <param name="connectionName">The name of the connection.</param> /// <param name="closeConnectionAfterInactivity">The time span to renew a connection after each message.</param> public HttpServerConnection(ITransportContext iTransportContext, Guid hostId, HostInformation remote, string connectionName, int closeConnectionAfterInactivity) { this.ITransportContext = iTransportContext; this.HttpServerConnectionManager = (HttpServerConnectionManager)iTransportContext.ConnectionManager; this.ConnectionName = connectionName; this.CloseConnectionAfterInactivity = closeConnectionAfterInactivity; this.HostId = hostId.ToByteArray(); this.HostIdAsString = hostId.ToString("N"); this.Listener_MessageContainer = new MessageContainer(iTransportContext); this.Remote = remote; }
public void TestCreateWithDefaultOptions() { Uri uri = new Uri("amqp://localhost:5672"); ITransportContext transportContext = TransportContextFactory.CreateTransportContext(uri); Assert.NotNull(transportContext); Assert.IsFalse(transportContext.IsSecure); Assert.AreEqual(8192, transportContext.ReceiveBufferSize); Assert.AreEqual(0, transportContext.ReceiveTimeout); Assert.AreEqual(8192, transportContext.SendBufferSize); Assert.AreEqual(0, transportContext.SendTimeout); Assert.IsTrue(transportContext.TcpNoDelay); }
/// <summary> /// Constructs an instance of the HostInformation class. /// Instances of the class HostInformation must be constructed only by objects implementing /// the IKnownHosts interface. /// </summary> /// <param name="uriOrUrl">Uri or Url of the remote host.</param> /// <param name="iTransportContext">Transport Context.</param> internal HostInformation(string uriOrUrl, ITransportContext iTransportContext) { this._iTransportContext = iTransportContext; if (uriOrUrl[0] == '_') { this._uri = uriOrUrl; UriStorage.RegisterConnection(uriOrUrl, this.ITransportContext); } else { this._url = uriOrUrl; } }
/// <summary> /// Constructs an instance of the HttpServerConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public HttpServerConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this.Local = new HostInformation("_ghttp://" + iTransportContext.HostIdentifier, iTransportContext); this._releaseConnections_InspectPersistentConnections = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.ReleaseConnections_InspectPersistentConnections); this._internal_TimerCallback_InspectPersistentConnections = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.Internal_TimerCallback_InspectPersistentConnections); // calculate host renewing timespan // this._hostRenewingSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]) + GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.MaxTimeSpanToReconnect]); this._internal_TimerCallback = new WaitCallback(Internal_TimerCallback); this._closeInvocationConnectionAfterInactivity = GenuineUtility.ConvertToMilliseconds(this.ITransportContext.IParameterProvider[GenuineParameter.CloseInvocationConnectionAfterInactivity]); TimerProvider.Attach(this); }
public TransportAction( string id, ITransportContext ctx, DbCommand cmdSrc, DbCommand cmdDst ) : base(id, ctx) { this.CmdSrc = cmdSrc; this.CmdDst = cmdDst; this.Source = new DbTransportSource(cmdSrc); this.Sink = new DbTransportSink(cmdSrc); this.Result = new TransportActionResult(id, TransportActionResultCode.None); this.Handlers = new List <DbDataReaderHandlerBase>(); }
/// <summary> /// Constructs an instance of the XHttpConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public XHttpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this._HalfSync_Client_onEndReceiving = new AsyncCallback(this.LowLevel_HalfSync_Client_EndReceiving); this._HalfSync_Server_onEndReceiving = new AsyncCallback(this.LowLevel_HalfSync_Server_EndReceiving); this._AsyncSending_onEndSending = new AsyncCallback(this.LowLevel_OnEndAsyncSending); this._internal_TimerCallback = new WaitCallback(this.Internal_TimerCallback); this._HalfSync_Client_onContinueReceiving = new WaitCallback(this.Pool_Client_ContinueHalfSyncReceiving); this._HalfSync_Server_onContinueReceiving = new WaitCallback(this.Pool_Server_ContinueHalfSyncReceiving); this._releaseConnections_InspectPersistentConnections = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.ReleaseConnections_InspectPersistentConnections); this._internal_TimerCallback_InspectPersistentConnections = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.Internal_TimerCallback_InspectPersistentConnections); this.Local = new HostInformation("_ghttp://" + iTransportContext.HostIdentifier, iTransportContext); TimerProvider.Attach(this); _xHttpReadHeaderTimeout = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.XHttpReadHttpMessageTimeout]); }
/// <summary> /// Constructs an instance of the HttpClientConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public HttpClientConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this.Local = new HostInformation("_ghttp://" + iTransportContext.HostIdentifier, iTransportContext); // calculate host renewing timespan this._hostRenewingSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]) + GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.MaxTimeSpanToReconnect]); this._internal_TimerCallback = new WaitCallback(Internal_TimerCallback); this._pool_Sender_OnEndSending_ContinueExchange = new WaitCallback(this.Pool_Sender_OnEndSending_ContinueExchange); this._listener_OnEndReceiving_ContinueExchange = new WaitCallback(this.Pool_Sender_OnEndSending_ContinueExchange); this._webRequestInitiationTimeout = (TimeSpan) iTransportContext.IParameterProvider[GenuineParameter.HttpWebRequestInitiationTimeout]; this._httpAsynchronousRequestTimeout = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.HttpAsynchronousRequestTimeout]); TimerProvider.Attach(this); }
public void TestCreateWithCustomOptions() { Uri uri = new Uri("amqp://localhost:5672" + "?" + "transport.receiveBufferSize=" + customReceiveBufferSize + "&" + "transport.receiveTimeout=" + customReceiveTimeout + "&" + "transport.sendBufferSize=" + customSendBufferSize + "&" + "transport.sendTimeout=" + customSendTimeout + "&" + "transport.tcpNoDelay=" + customTcpNoDelay); ITransportContext transportContext = TransportContextFactory.CreateTransportContext(uri); Assert.NotNull(transportContext); Assert.IsFalse(transportContext.IsSecure); Assert.AreEqual(customReceiveBufferSize, transportContext.ReceiveBufferSize); Assert.AreEqual(customReceiveTimeout, transportContext.ReceiveTimeout); Assert.AreEqual(customSendBufferSize, transportContext.SendBufferSize); Assert.AreEqual(customSendTimeout, transportContext.SendTimeout); Assert.AreEqual(customTcpNoDelay, transportContext.TcpNoDelay); }
/// <summary> /// Constructs an instance of the Message class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="recipient">Recipient.</param> /// <param name="replyToId">Source id or zero.</param> /// <param name="iTransportHeaders">Transport headers.</param> /// <param name="stream">Message.</param> public Message(ITransportContext iTransportContext, HostInformation recipient, int replyToId, ITransportHeaders iTransportHeaders, Stream stream) { this.ITransportContext = iTransportContext; this.ITransportHeaders = iTransportHeaders; this.Recipient = recipient; this.ReplyToId = replyToId; this.Stream = stream; if (this.ITransportHeaders != null) { this.ITransportHeaders[TransportHeadersSenderEntryName] = this.Sender; } this.MessageId = Interlocked.Increment(ref _currentMessageId); #if TRIAL if (this.MessageId > 3001) { throw GenuineExceptions.Get_Channel_TrialConditionExceeded("The maximum number of messages restriction has been exceeded. You can not send more than 3000 messages using TRIAL version."); } #endif }
/// <summary> /// Answers Genuine Channels URI and Transport Context via which access to the remote /// MarshalByRefObject object is performed. /// </summary> /// <param name="marshalByRefObject">MarshalByRefObject instance to fetch the URI from.</param> /// <param name="uri">The uri.</param> /// <param name="iTransportContext">The transport context.</param> public static void FetchChannelUriFromMbr(MarshalByRefObject marshalByRefObject, out string uri, out ITransportContext iTransportContext) { IDictionary iDictionary = ChannelServices.GetChannelSinkProperties(marshalByRefObject); uri = iDictionary["GC_URI"] as string; iTransportContext = iDictionary["GC_TC"] as ITransportContext; }
/// <summary> /// Constructs an instance of the DirectExchangeManager class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> public DirectExchangeManager(ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; }
/// <summary> /// Constructs an instance of the HttpServerConnection class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="hostId">The id of the remote host.</param> /// <param name="remote">The remote host.</param> /// <param name="connectionName">The name of the connection.</param> /// <param name="closeConnectionAfterInactivity">The time span to renew a connection after each message.</param> public HttpServerConnection(ITransportContext iTransportContext, Guid hostId, HostInformation remote, string connectionName, int closeConnectionAfterInactivity) { this.ITransportContext = iTransportContext; this.HttpServerConnectionManager = (HttpServerConnectionManager) iTransportContext.ConnectionManager; this.ConnectionName = connectionName; this.CloseConnectionAfterInactivity = closeConnectionAfterInactivity; this.HostId = hostId.ToByteArray(); this.HostIdAsString = hostId.ToString("N"); this.Listener_MessageContainer = new MessageContainer(iTransportContext); this.Remote = remote; }
public InformationService(ITransportContext context) { _context = context ?? throw new ArgumentNullException(nameof(context)); }
/// <summary> /// Initializes an instance of the AsyncSinkStackResponseProcessor class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="message">Source message.</param> /// <param name="iClientChannelSinkStack">The client channel sink stack.</param> public AsyncSinkStackResponseProcessor(ITransportContext iTransportContext, Message message, IClientChannelSinkStack iClientChannelSinkStack) { this._iTransportContext = iTransportContext; this._message = message; this._iClientChannelSinkStack = iClientChannelSinkStack; }
/// <summary> /// Constructs an instance of the HttpInvocationConnection class. /// </summary> /// <param name="iTransportContext">The transport context.</param> /// <param name="remote">The remote host.</param> public HttpInvocationConnection(ITransportContext iTransportContext, HostInformation remote) { this.HostId = iTransportContext.BinaryHostIdentifier; this.HostIdAsString = iTransportContext.HostIdentifier; this._asyncCallback_onRequestCompleted = new AsyncCallback(this.OnRequestCompleted); this.ITransportContext = iTransportContext; this.Remote = remote; // this.OnEndSending = new AsyncCallback(this.Callback_OnEndSending); // this.OnEndReceiving = new AsyncCallback(this.Callback_OnEndReceiving); // cache all setting's values this._userAgent = this.ITransportContext.IParameterProvider[GenuineParameter.HttpWebUserAgent] as string; if (this._userAgent == null) { this._userAgent = @"Mozilla/4.0+ (compatible; MSIE 6.0; Windows " + Environment.OSVersion.Version + "; Genuine HTTP Client Channel; MS .NET CLR " + Environment.Version.ToString() + ")"; } this._userAgent = Regex.Replace(this._userAgent, "\r|\n", " ", RegexOptions.None); this._useUnsafeConnectionSharing = (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUnsafeConnectionSharing]; this._allowWriteStreamBuffering = (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpAllowWriteStreamBuffering]; this._keepalive = (bool)iTransportContext.IParameterProvider[GenuineParameter.HttpKeepAlive]; this._credentials = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthCredential] as ICredentials; string userName = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthUserName] as string; string password = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthPassword] as string; string domain = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthDomain] as string; this._hostRenewingSpan = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]) + GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.MaxTimeSpanToReconnect]); if (this._credentials != null || (userName != null && userName != string.Empty && password != null && password != string.Empty)) { this._useWebAuthentication = true; // and setup credentials if (this._credentials == null) { if ((bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseDefaultCredentials]) { this._credentials = CredentialCache.DefaultCredentials; } else { if (domain == null) { this._credentials = new NetworkCredential(userName, password); } else { this._credentials = new NetworkCredential(userName, password, domain); } } } } if ((bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseGlobalProxy]) { #if (FRM20) this._iWebProxy = WebRequest.DefaultWebProxy; #else this._iWebProxy = GlobalProxySelection.Select; #endif } else { if (!(this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri] is string)) { #if (FRM20) this._iWebProxy = null; #else this._iWebProxy = GlobalProxySelection.GetEmptyWebProxy(); #endif } else { this._iWebProxy = new WebProxy((string)this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri], (bool)this.ITransportContext.IParameterProvider[GenuineParameter.HttpBypassOnLocal]); } } this._httpAsynchronousRequestTimeout = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.HttpAsynchronousRequestTimeout]); }
/// <summary> /// Constructs an instance of the GeneralBroadcastSender class. /// </summary> /// <param name="court">The court.</param> /// <param name="iTransportContext">The Transport Ñontext.</param> public GeneralBroadcastSender(string court, ITransportContext iTransportContext) { this._court = court; this._iTransportContext = iTransportContext; }
/// <summary> /// Constructs an instance of the TcpSocketInfo class. /// </summary> /// <param name="socket">The socket.</param> /// <param name="iTransportContext">Transport Context.</param> /// <param name="connectionName">The name of the connection.</param> /// <param name="typeOfSocket">The type of the socket used for debugging.</param> internal TcpSocketInfo(Socket socket, ITransportContext iTransportContext, string connectionName #if DEBUG ,string typeOfSocket #endif ) { this.Socket = socket; this.ITransportContext = iTransportContext; this.ConnectionName = connectionName == null ? "~" + Guid.NewGuid().ToString("N") : connectionName; this.MaxSendSize = (int) this.ITransportContext.IParameterProvider[GenuineParameter.TcpMaxSendSize]; #if DEBUG this._typeOfSocket = typeOfSocket; this._connectionNumber = Interlocked.Increment(ref _dbg_ConnectionCounter); #endif }
/// <summary> /// Constructs the response to the specified message. /// </summary> /// <param name="sourceMessage">The source message.</param> /// <param name="iTransportHeaders">The transport headers.</param> /// <param name="stream">The message content.</param> public Message(Message sourceMessage, ITransportHeaders iTransportHeaders, Stream stream) { this.ITransportContext = sourceMessage.ITransportContext; this.ITransportHeaders = iTransportHeaders; // this.Sender = sourceMessage.Recipient; this.Recipient = sourceMessage.Sender; this.ReplyToId = sourceMessage.MessageId; this.GenuineMessageType = sourceMessage.GenuineMessageType; this.Stream = stream; this.ConnectionName = sourceMessage.ConnectionName; this.SecuritySessionParameters = this.ITransportContext.FixSecuritySessionParameters(sourceMessage.SecuritySessionParameters); this.IsSynchronous = (this.SecuritySessionParameters.Attributes & SecuritySessionAttributes.ForceSync) != 0 || ((bool) this.ITransportContext.IParameterProvider[GenuineParameter.SyncResponses] && (this.SecuritySessionParameters.Attributes & SecuritySessionAttributes.ForceAsync) == 0); if (this.ITransportHeaders != null) this.ITransportHeaders[TransportHeadersSenderEntryName] = this.Sender; this.MessageId = Interlocked.Increment(ref _currentMessageId); #if TRIAL if (this.MessageId > 3010) throw GenuineExceptions.Get_Channel_TrialConditionExceeded("The maximum number of messages restriction has been exceeded. You can not send more than 3000 messages using TRIAL version."); #endif }
public AmqpProvider(Uri remoteUri, ITransportContext transport) { RemoteUri = remoteUri; this.transport = transport; }
/// <summary> /// Initializes the instance of the SyncSinkStackResponseProcessor class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="message">The source message.</param> public SyncSinkStackResponseProcessor(ITransportContext iTransportContext, Message message) { this._iTransportContext = iTransportContext; this._message = message; }
/// <summary> /// Initializes an instance of the IPMulticastSender class. /// </summary> /// <param name="court">The name of the destination court.</param> /// <param name="iTransportContext">The Transport Context.</param> public IPMulticastSender(string court, ITransportContext iTransportContext) : base(court, iTransportContext) { }
/// <summary> /// Constructs an instance of the Message class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="recipient">Recipient.</param> /// <param name="replyToId">Source id or zero.</param> /// <param name="iTransportHeaders">Transport headers.</param> /// <param name="stream">Message.</param> public Message(ITransportContext iTransportContext, HostInformation recipient, int replyToId, ITransportHeaders iTransportHeaders, Stream stream) { this.ITransportContext = iTransportContext; this.ITransportHeaders = iTransportHeaders; this.Recipient = recipient; this.ReplyToId = replyToId; this.Stream = stream; if (this.ITransportHeaders != null) this.ITransportHeaders[TransportHeadersSenderEntryName] = this.Sender; this.MessageId = Interlocked.Increment(ref _currentMessageId); #if TRIAL if (this.MessageId > 3001) throw GenuineExceptions.Get_Channel_TrialConditionExceeded("The maximum number of messages restriction has been exceeded. You can not send more than 3000 messages using TRIAL version."); #endif }
/// <summary> /// Constructs an instance of the TcpConnectionManager class. /// </summary> /// <param name="iTransportContext">The transport context.</param> public TcpConnectionManager(ITransportContext iTransportContext) : base(iTransportContext) { this._onEndSending = new AsyncCallback(this.LowLevel_EndSending); this._internal_TimerCallback = new WaitCallback(this.Internal_TimerCallback); this._HalfSync_onContinueReceiving = new WaitCallback(this.Pool_ContinueHalfSyncReceiving); this._HalfSync_onEndReceiving = new AsyncCallback(this.LowLevel_HalfSync_EndReceiving); this._lowLevel_Client_PreventDelayedAck = new WaitCallback(this.LowLevel_Client_PreventDelayedAck); this._processObjectLateBoundHandler = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.FindExpiredConnections); this._releaseConnections_InspectPersistentConnections = new PersistentConnectionStorage.ProcessConnectionEventHandler(this.ReleaseConnections_InspectPersistentConnections); this._tcpReadRequestBeforeProcessing = (bool) iTransportContext.IParameterProvider[GenuineParameter.TcpReadRequestBeforeProcessing]; this.Local = new HostInformation("_gtcp://" + iTransportContext.HostIdentifier, iTransportContext); TimerProvider.Attach(this); }
/// <summary> /// Creates an instance of the GenuineTcpServerTransportSink class. /// </summary> /// <param name="channel">The parent channel.</param> /// <param name="nextChannelSink">The next channel sink for futher processing.</param> /// <param name="iTransportContext">The Transport Context.</param> public GenuineUniversalServerTransportSink(BasicChannelWithSecurity channel, IServerChannelSink nextChannelSink, ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; this._channel = channel; this._nextChannelSink = nextChannelSink; }
/// <summary> /// Constructs an instance of the GenuineTcpClientTransportSinkProvider class. /// </summary> /// <param name="iTransportContext">Transport Context.</param> public GenuineTcpClientTransportSinkProvider(ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; }
/// <summary> /// Constructs an instance of the SharedMemoryConnection class. /// </summary> /// <param name="iTransportContext">The transport context.</param> /// <param name="name">The name of the shared chunk.</param> /// <param name="isServer">The role.</param> /// <param name="setCloseStatusOnExit">Indicates whether it is necessary to set the "closed" status on exit.</param> internal SharedMemoryConnection(ITransportContext iTransportContext, string name, bool isServer, bool setCloseStatusOnExit) { this.ITransportContext = iTransportContext; this.ShareName = "GenuineChannels_GShMem_" + name; this.IsServer = isServer; this._setCloseStatusOnExit = setCloseStatusOnExit; this._shareSize = (int)iTransportContext.IParameterProvider[GenuineParameter.SMShareSize]; this._pingTimeOut = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.PersistentConnectionSendPingAfterInactivity]); this._closeAfterInactivity = GenuineUtility.ConvertToMilliseconds(iTransportContext.IParameterProvider[GenuineParameter.ClosePersistentConnectionAfterInactivity]); string localSideName = (isServer ? "Server" : "Client"); string remoteSideName = (isServer ? "Client" : "Server"); IParameterProvider parameters = this.ITransportContext.IParameterProvider; // construct shared object names for the local side string readCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName( this.ShareName + localSideName + "ReadCompleted", parameters); string writeCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName( this.ShareName + localSideName + "WriteCompleted", parameters); // construct shared object names for the remote side string remoteReadCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName( this.ShareName + remoteSideName + "ReadCompleted", parameters); string remoteWriteCompletedEventName = GenuineSharedMemoryChannel.ConstructSharedObjectName( this.ShareName + remoteSideName + "WriteCompleted", parameters); if (isServer) { if (this._shareSize < MIN_SHARE_SIZE || this._shareSize > MAX_SHARE_SIZE) { throw GenuineExceptions.Get_Channel_InvalidParameter("SMShareSize"); } this.LowLevel_CreateSharedMemory(); this._closed = 0; this._writtenShareSize = this._shareSize; this._receiveOffset = 5; this._sendOffset = (this._shareSize - 5) / 2; this._receiveSpaceSize = this._sendOffset - 5 - 8; this._sendSpaceSize = this._shareSize - this._sendOffset - 8; this._namedEventReadCompleted = NamedEvent.CreateNamedEvent(readCompletedEventName, false, true); this._namedEventWriteCompleted = NamedEvent.CreateNamedEvent(writeCompletedEventName, false, true); this._namedEventRemoteReadCompleted = NamedEvent.CreateNamedEvent(remoteReadCompletedEventName, false, true); this._namedEventRemoteWriteCompleted = NamedEvent.CreateNamedEvent(remoteWriteCompletedEventName, false, true); } else { this.OpenSharedMemory(); if (this._closed != 0) { throw GenuineExceptions.Get_Connect_CanNotConnectToRemoteHost(name, "Remote host has already closed the connection."); } this._shareSize = this._writtenShareSize; if (this._shareSize < MIN_SHARE_SIZE || this._shareSize > MAX_SHARE_SIZE) { throw GenuineExceptions.Get_Channel_InvalidParameter("SMShareSize"); } this._receiveOffset = (this._shareSize - 5) / 2; this._sendOffset = 5; this._receiveSpaceSize = this._shareSize - this._receiveOffset - 8; this._sendSpaceSize = this._receiveOffset - 5 - 8; this._namedEventReadCompleted = NamedEvent.OpenNamedEvent(readCompletedEventName); this._namedEventWriteCompleted = NamedEvent.OpenNamedEvent(writeCompletedEventName); this._namedEventRemoteReadCompleted = NamedEvent.OpenNamedEvent(remoteReadCompletedEventName); this._namedEventRemoteWriteCompleted = NamedEvent.OpenNamedEvent(remoteWriteCompletedEventName); } this._sendBuffer = new byte[this._sendSpaceSize]; }
/// <summary> /// Registers message handler. /// Overrides old message handlers with the same names. /// </summary> /// <param name="remoteUri">The URI of the remote host.</param> /// <param name="iTransportContext">Transport Context servicing a connection to the remote host.</param> public static void RegisterConnection(string remoteUri, ITransportContext iTransportContext) { _knownUris[remoteUri] = new WeakReference(iTransportContext); }
/// <summary> /// Makes message up from the IMessage. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="iMessage">IMessage to make the message up from.</param> /// <param name="iTransportHeaders">Trasport headers.</param> /// <param name="stream">Message body.</param> /// <param name="isSynchronous">True if the invocation is synchronous.</param> /// <returns>An instance of the Message class.</returns> public static Message CreateOutcomingMessage(ITransportContext iTransportContext, IMessage iMessage, ITransportHeaders iTransportHeaders, Stream stream, bool isSynchronous) { // when microsoft guys start caring about detailed .NET remoting documentation??? string url = (string) iMessage.Properties["__Uri"]; string objectURI; string channelUri = GenuineUtility.Parse(url, out objectURI); if (objectURI == null) objectURI = url; // not well-known object iTransportHeaders[TransportHeaderName_RemoteObjectUri] = objectURI; Message message = new Message(iTransportContext, null, 0, iTransportHeaders, stream); message.IMessage = iMessage; message.IsSynchronous = isSynchronous; if (iTransportHeaders[Message.TransportHeadersGenuineMessageType] != null) message.GenuineMessageType = (GenuineMessageType) iTransportHeaders[Message.TransportHeadersGenuineMessageType]; return message; }
/// <summary> /// Constructs an instance of the HttpClientConnection class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> /// <param name="connectionName">The name of the connection.</param> public HttpClientConnection(ITransportContext iTransportContext, string connectionName) { this.HostId = iTransportContext.BinaryHostIdentifier; this.HostIdAsString = iTransportContext.HostIdentifier; this.ConnectionName = connectionName; this.ITransportContext = iTransportContext; this.HttpClientConnectionManager = (HttpClientConnectionManager) this.ITransportContext.ConnectionManager; this.MessageContainer = new MessageContainer(iTransportContext); // the less buffer the less performance this.Sender_SendBuffer = new byte[35000]; this.Sender_ReceiveBuffer = new byte[35000]; this.Listener_ReceiveBuffer = new byte[35000]; this.OnEndSending = new AsyncCallback(this.Callback_OnEndSending); this.OnEndReceiving = new AsyncCallback(this.Callback_OnEndReceiving); // cache all setting's values this._userAgent = this.ITransportContext.IParameterProvider[GenuineParameter.HttpWebUserAgent] as string; this._mimeMediaType = this.ITransportContext.IParameterProvider[GenuineParameter.HttpMimeMediaType] as string; if (this._userAgent == null) this._userAgent = @"Mozilla/4.0+ (compatible; MSIE 6.0; Windows " + Environment.OSVersion.Version + "; Genuine HTTP Client Channel; MS .NET CLR " + Environment.Version.ToString() + ")"; this._userAgent = Regex.Replace(this._userAgent, "\r|\n", " ", RegexOptions.None); this._useUnsafeConnectionSharing = (bool) this.ITransportContext.IParameterProvider[GenuineParameter.HttpUnsafeConnectionSharing]; this._allowWriteStreamBuffering = (bool) this.ITransportContext.IParameterProvider[GenuineParameter.HttpAllowWriteStreamBuffering]; this._keepalive = (bool) iTransportContext.IParameterProvider[GenuineParameter.HttpKeepAlive]; this._credentials = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthCredential] as ICredentials; string userName = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthUserName] as string; string password = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthPassword] as string; string domain = this.ITransportContext.IParameterProvider[GenuineParameter.HttpAuthDomain] as string; bool httpUseDefaultCredentials = (bool) this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseDefaultCredentials]; if (this._credentials != null || (userName != null && userName != string.Empty && password != null && password != string.Empty) || httpUseDefaultCredentials) { this._useWebAuthentication = true; // and setup credentials if (this._credentials == null) { if (httpUseDefaultCredentials) this._credentials = CredentialCache.DefaultCredentials; else { if (domain == null) this._credentials = new NetworkCredential(userName, password); else this._credentials = new NetworkCredential(userName, password, domain); } } } if ((bool) this.ITransportContext.IParameterProvider[GenuineParameter.HttpUseGlobalProxy]) { #if (FRM20) this._iWebProxy = WebRequest.DefaultWebProxy; #else this._iWebProxy = GlobalProxySelection.Select; #endif } else { if (! (this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri] is string) ) { #if (FRM20) this._iWebProxy = null; #else this._iWebProxy = GlobalProxySelection.GetEmptyWebProxy(); #endif } else this._iWebProxy = new WebProxy((string) this.ITransportContext.IParameterProvider[GenuineParameter.HttpProxyUri], (bool) this.ITransportContext.IParameterProvider[GenuineParameter.HttpBypassOnLocal]); } }
/// <summary> /// Constructs an instance of the KnownHosts class. /// </summary> public KnownHosts(ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; TimerProvider.Attach(this); }
/// <summary> /// Constructs an instance of the GeneralConnection class. /// </summary> /// <param name="iTransportContext">The Transport Context.</param> public GeneralConnection(ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; this.HostIdAsString = iTransportContext.HostIdentifier; }
/// <inheritdoc /> public Task CopyToAsync(IStream stream, ITransportContext context) { return(Implementation.CopyToAsync(stream.ToImplementation(), context.ToImplementation())); }
/// <summary> /// Constructs an instance of the GenuineReceivingHandler class. /// </summary> /// <param name="iTransportContext">Transport context.</param> /// <param name="defaultTransportUser">Default transport user.</param> public GenuineReceivingHandler(ITransportContext iTransportContext, ITransportUser defaultTransportUser) { this.ITransportContext = iTransportContext; this.DefaultTransportUser = defaultTransportUser; this._waitCallback_InternalExecuteMessagewaitCallback = new WaitCallback(this.InternalExecuteMessage); TimerProvider.Attach(this); }
/// <summary> /// Registers the receiver and associate the provided object with it. /// Returns false if the receiver has already been registered. /// WARNING: does not check whether the receiver supports the required interface (via Reflection) /// because this check requires client's dll. /// </summary> /// <param name="obj">The receiver being registered.</param> /// <param name="tag">The object associated with the receiver. This object is accessible when receiver is being unregistered or during filtering.</param> /// <param name="remoteGenuineUri">The uri of the remote host provided by any of Genuine Channels.</param> /// <param name="transportContext">The transport context of the remote host.</param> /// <returns>False if the receiver has been already registered.</returns> public bool Add(MarshalByRefObject obj, object tag, string remoteGenuineUri, ITransportContext transportContext) { if (obj == null) throw new ArgumentNullException("obj"); BinaryLogWriter binaryLogWriter = GenuineLoggingServices.BinaryLogWriter; // check if it is in the list string uri = RemotingServices.GetObjectUri(obj); if (uri == null && ! RemotingServices.IsObjectOutOfAppDomain(obj)) { // it was not marshalled RemotingServices.Marshal(obj); uri = RemotingServices.GetObjectUri(obj); } using (ReaderAutoLocker reader = new ReaderAutoLocker(this._readerWriterLock)) { if (this._receivers.ContainsKey(uri)) return false; } // this check can not be performed because client's dll is required // // check on the interface // bool supportInterface = false; // foreach(Type interfaceType in obj.GetType().GetInterfaces()) // if (interfaceType == this._interfaceToSupport) // { // supportInterface = true; // break; // } // if (! supportInterface) // throw GenuineExceptions.Get_Broadcast_ObjectDoesNotSupportDestinationInterface(); // adds the object to the receiver list ReceiverInfo receiverInfo = new ReceiverInfo(); receiverInfo.MbrObject = obj; receiverInfo.MbrUri = uri; receiverInfo.Tag = tag; if (binaryLogWriter != null) { try { if (receiverInfo.MbrObject != null) receiverInfo.DbgRemoteHost = GenuineUtility.FetchHostInformationFromMbr(receiverInfo.MbrObject); } catch(Exception ex) { binaryLogWriter.WriteImplementationWarningEvent("Dispatcher.Add", LogMessageType.Error, ex, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, "Can't get HostInformation from MbrObject."); } } ObjRef objRef = receiverInfo.MbrObject.CreateObjRef(typeof(MarshalByRefObject)); receiverInfo.Local = objRef.IsFromThisAppDomain(); // cache object's info to speed up sending thru Genuine Channels if (! receiverInfo.Local) { if (remoteGenuineUri != null) { receiverInfo.IClientChannelSink = new GenuineTcpClientTransportSink(remoteGenuineUri, transportContext); } else { // check whether the client sink has registered itself on this MBR receiverInfo.IClientChannelSink = ChannelServices.GetChannelSinkProperties(obj)["GC_TS"] as IClientChannelSink; if (receiverInfo.IClientChannelSink == null) throw GenuineExceptions.Get_Broadcast_ClientSinkIsUnknown(); } // object uri receiverInfo.SerializedObjRef = objRef; // // and shell's uri // string shellUri; // ITransportContext iTransportContext; // GenuineUtility.FetchChannelUriFromMbr(obj, out shellUri, out iTransportContext); // if (shellUri == null) // throw GenuineExceptions.Get_Send_NoSender(objRef.URI); // // receiverInfo.ReceiverUri = shellUri; } // LOG: if ( binaryLogWriter != null && binaryLogWriter[LogCategory.BroadcastEngine] > 0 ) { binaryLogWriter.WriteBroadcastEngineEvent(LogCategory.BroadcastEngine, "Dispatcher.Add", LogMessageType.BroadcastRecipientAdded, null, null, receiverInfo.DbgRemoteHost, null, GenuineUtility.CurrentThreadId, Thread.CurrentThread.Name, null, null, false, this, null, true, receiverInfo, null, null, "The broadcast recipient is added."); } // register the sponsor to prevent unexpected reclaiming ILease lease = (ILease) RemotingServices.GetLifetimeService(obj); if (lease != null) lease.Register(this.GlobalSponsor); // and register it using (WriterAutoLocker writer = new WriterAutoLocker(this._readerWriterLock)) { this._cachedReceiversInfoArray = null; this._receivers[uri] = receiverInfo; } return true; }
/// <summary> /// Constructs an instance of the ConnectionManager class. /// </summary> /// <param name="iTransportContext">The Transport context.</param> public ConnectionManager(ITransportContext iTransportContext) { this.ITransportContext = iTransportContext; }
/// <summary> /// Constructs an instance of the TcpSocketInfo class. /// </summary> /// <param name="socket">The socket.</param> /// <param name="iTransportContext">Transport Context.</param> /// <param name="connectionName">The name of the connection.</param> /// <param name="typeOfSocket">The type of the socket used for debugging.</param> internal TcpSocketInfo(Socket socket, ITransportContext iTransportContext, string connectionName, string typeOfSocket)