/// <summary> /// Creates and configures a Remoting channel. /// </summary> /// <returns>Remoting channel</returns> public override IChannel CreateChannel() { IChannel channel = ChannelServices.GetChannel(_channelName); if (channel == null) { _channelSettings["name"] = _channelName; _channelSettings["port"] = _httpPort; _channelSettings["bindTo"] = _ipAddress; _channelSettings["secure"] = false; ConfigureEncryption(); ConfigureCompression(); if (_channelFactory == null) { throw new ApplicationException(LanguageResource.ApplicationException_NoChannelFactorySpecified); } channel = _channelFactory(_channelSettings, BuildClientSinkChain(), BuildServerSinkChain()); RemotingHelper.ResetCustomErrorsMode(); } return(channel); }
//este boton tiene la instancia que levanta el server private void button1_Click(object sender, EventArgs e) { try { int puerto_server = Convert.ToInt32(tb_client_port.Text); if (Channel != null) { } else { Channel = new TcpChannel(puerto_server); if (ChannelServices.GetChannel(Channel.ChannelName) != null) { } else { ChannelServices.RegisterChannel(Channel, false); } } RemotingConfiguration.RegisterWellKnownServiceType( typeof(Libreria.Class1), "chat", WellKnownObjectMode.Singleton); local = (Class1)Activator.GetObject(typeof(Class1), "tcp://localhost:" + tb_client_port.Text + "/chat"); button1.Enabled = false; tb_client_port.Enabled = false; // button2.Enabled = true; timer1.Start(); MessageBox.Show("Servidor ha sido montado!"); } catch (Exception ex) { MessageBox.Show(ex.Message); } }
/// <summary> /// Get a channel by name, casting it to a TcpChannel. /// Otherwise, create, register and return a TcpChannel with /// that name, on the port provided as the second argument. /// </summary> /// <param name="name">The channel name</param> /// <param name="port">The port to use if the channel must be created</param> /// <param name="limit">The client connection limit or negative for the default</param> /// <returns>A TcpChannel or null</returns> public static TcpChannel GetTcpChannel(string name, int port, int limit) { TcpChannel channel = ChannelServices.GetChannel(name) as TcpChannel; if (channel == null) { // NOTE: Retries are normally only needed when rapidly creating // and destroying channels, as in running the NUnit tests. int retries = 10; while (--retries > 0) { try { channel = CreateTcpChannel(name, port, limit); #if CLR_2_0 || CLR_4_0 ChannelServices.RegisterChannel(channel, false); #else ChannelServices.RegisterChannel(channel, false); #endif break; } catch (Exception e) { System.Threading.Thread.Sleep(300); } } } return(channel); }
string RegisterRemotingChannel() { if (remotingChannel == "tcp") { IChannel ch = ChannelServices.GetChannel("tcp"); if (ch == null) { IDictionary dict = new Hashtable(); BinaryClientFormatterSinkProvider clientProvider = new BinaryClientFormatterSinkProvider(); BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); dict["port"] = 0; serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full; ChannelServices.RegisterChannel(new TcpChannel(dict, clientProvider, serverProvider), false); } } else { IChannel ch = ChannelServices.GetChannel("unix"); if (ch == null) { unixRemotingFile = Path.GetTempFileName(); ChannelServices.RegisterChannel(new UnixChannel(unixRemotingFile), false); } } return(remotingChannel); }
string RegisterRemotingChannel(IsolationMode mode) { string remotingChannel; if (mode == IsolationMode.ProcessTcp) { remotingChannel = "tcp"; IChannel ch = ChannelServices.GetChannel("tcp"); if (ch == null) { ChannelServices.RegisterChannel(new TcpChannel(0), false); } } else { remotingChannel = "unix"; IChannel ch = ChannelServices.GetChannel("unix"); if (ch == null) { string unixRemotingFile = Path.GetTempFileName(); ChannelServices.RegisterChannel(new UnixChannel(unixRemotingFile), false); } } return(remotingChannel); }
/// <summary> /// Get a channel by name, casting it to a <see cref="TcpChannel"/>. /// Otherwise, create, register and return a <see cref="TcpChannel"/> with /// that name, on the port provided as the second argument. /// </summary> /// <param name="name">The name of the channel</param> /// <param name="port">The port to use if the channel must be created.</param> /// <param name="limit">The client connection limit or negative for the default.</param> /// <param name="currentMessageCounter">An optional counter to provide the ability to wait for all current messages.</param> /// <returns>The specified <see cref="TcpChannel"/> or <see langword="null"/> if it cannot be found and created.</returns> public static TcpChannel GetTcpChannel(string name, int port, int limit, CurrentMessageCounter currentMessageCounter = null) { var existingChannel = ChannelServices.GetChannel(name) as TcpChannel; if (existingChannel != null) { return(existingChannel); } // NOTE: Retries are normally only needed when rapidly creating // and destroying channels, as in running the NUnit tests. for (var retries = 0; retries < 10; retries++) { try { var newChannel = CreateTcpChannel(name, port, limit, currentMessageCounter); ChannelServices.RegisterChannel(newChannel, false); return(newChannel); } catch (Exception ex) { Log.Error("Failed to create/register channel", ex); Thread.Sleep(300); } } return(null); }
private void btnjoin_Click(object sender, EventArgs e) { try { if (client_channel == null) { client_channel = new TcpChannel(); ChannelServices.RegisterChannel(client_channel, false); } remota = (Class1)Activator.GetObject(typeof(Class1), tb_server_tcp_chan.Text); if (remota.its_in_tha_room(n_user.nickname, n_user.ip, n_user.port)) { MessageBox.Show("El usuario ya esta en sala o nickname ya tomado."); if (ChannelServices.GetChannel(client_channel.ChannelName) != null) { ChannelServices.UnregisterChannel(client_channel); } } else { remota.Subscribe(n_user.nickname, n_user.ip, n_user.port); MessageBox.Show("Te has unido a la sala"); timer1.Start(); } } catch (Exception ex) { if (ChannelServices.GetChannel(client_channel.ChannelName) != null) { ChannelServices.UnregisterChannel(client_channel); } MessageBox.Show("No se ha podido unir a la sala: " + ex.Message); } }
static void Main(string[] args) { try { String filename = "client.exe.config"; RemotingConfiguration.Configure(filename); CustomerManager mgr = new CustomerManager(); Console.WriteLine("Client.Main(): Reference to CustomerManager " + " acquired"); IChannel chnl = ChannelServices.GetChannel("http"); Object obj = ChannelServices.RegisteredChannels; IDictionary props = ChannelServices.GetChannelSinkProperties(mgr); props["username"] = "******"; props["password"] = "******"; props["preauthenticate"] = "True"; Customer cust = mgr.getCustomer(4711); int age = cust.getAge(); Console.WriteLine("Client.Main(): Customer {0} {1} is {2} years old.", cust.FirstName, cust.LastName, age); } catch (Exception e) { Console.WriteLine("EX: {0}", e.Message); } Console.ReadLine(); }
/// <summary> /// Publish objects so that the host can use it, and then block indefinitely (until the input stream is open). /// /// Note that we should publish only one object, and then have other objects be accessible from it. Publishing /// multiple objects can cause problems if the client does a call like "remoteProxy1(remoteProxy2)" as remoting /// will not be able to know if the server object for both the proxies is on the same server. /// </summary> /// <param name="remoteRuntimeChannelName">The IPC channel that the remote console expects to use to communicate with the ScriptEngine</param> /// <param name="scope">A intialized ScriptScope that is ready to start processing script commands</param> internal static void StartServer(string remoteRuntimeChannelName, ScriptScope scope) { Debug.Assert(ChannelServices.GetChannel(remoteRuntimeChannelName) == null); IpcChannel channel = CreateChannel("ipc", remoteRuntimeChannelName); LifetimeServices.LeaseTime = GetSevenDays(); LifetimeServices.LeaseManagerPollTime = GetSevenDays(); LifetimeServices.RenewOnCallTime = GetSevenDays(); LifetimeServices.SponsorshipTimeout = GetSevenDays(); ChannelServices.RegisterChannel(channel, false); try { RemoteCommandDispatcher remoteCommandDispatcher = new RemoteCommandDispatcher(scope); RemotingServices.Marshal(remoteCommandDispatcher, CommandDispatcherUri); // Let the remote console know that the startup output (if any) is complete. We use this instead of // a named event as we want all the startup output to reach the remote console before it proceeds. Console.WriteLine(RemoteCommandDispatcher.OutputCompleteMarker); // Block on Console.In. This is used to determine when the host process exits, since ReadLine will return null then. string input = System.Console.ReadLine(); Debug.Assert(input == null); } finally { ChannelServices.UnregisterChannel(channel); } }
/// <summary> /// Creates and configures a Remoting channel. /// </summary> /// <returns>Remoting channel</returns> public override IChannel CreateChannel() { IChannel channel = ChannelServices.GetChannel(_channelName); if (channel == null) { _channelSettings["name"] = _channelName; _channelSettings["port"] = 0; _channelSettings["secure"] = _useWindowsSecurity; _channelSettings["socketCacheTimeout"] = 0; _channelSettings["socketCachePolicy"] = SocketCachingEnabled ? SocketCachePolicy.Default : SocketCachePolicy.AbsoluteTimeout; if (_useWindowsSecurity) { _channelSettings["tokenImpersonationLevel"] = _impersonationLevel; _channelSettings["protectionLevel"] = _protectionLevel; } if (_channelFactory == null) { throw new ApplicationException(LanguageResource.ApplicationException_NoChannelFactorySpecified); } channel = _channelFactory(_channelSettings, BuildClientSinkChain(), BuildServerSinkChain()); RemotingHelper.ResetCustomErrorsMode(); } return(channel); }
internal static IpcServerChannel IpcCreateServer <T>(string domain, string portName, WellKnownObjectMode mode, T obj) where T : MarshalByRefObject { IpcServerChannel channel = ChannelServices.GetChannel(domain) as IpcServerChannel; if (channel == null) { BinaryServerFormatterSinkProvider serverProvider = new BinaryServerFormatterSinkProvider(); serverProvider.TypeFilterLevel = System.Runtime.Serialization.Formatters.TypeFilterLevel.Full; //Instantiate our server channel. channel = new IpcServerChannel(domain, domain, serverProvider); //Register the server channel. ChannelServices.RegisterChannel(channel, false); } var c = channel.GetChannelUri(); //Register this service type. if (obj == null) { RemotingConfiguration.RegisterWellKnownServiceType(typeof(T), portName, mode); } else { RemotingServices.Marshal(obj, portName); } return(channel); }
/// <summary> /// Creates and configures a Remoting channel. /// </summary> /// <returns>Remoting channel</returns> public override IChannel CreateChannel() { IChannel channel = ChannelServices.GetChannel(_channelName); if (channel == null) { _channelSettings["name"] = _channelName; _channelSettings["port"] = 0; _channelSettings["listen"] = false; _channelSettings["typeFilterLevel"] = TypeFilterLevel.Full; _channelSettings["keepAliveEnabled"] = _tcpKeepAliveEnabled; _channelSettings["keepAliveTime"] = _tcpKeepAliveTime; _channelSettings["keepAliveInterval"] = _tcpKeepAliveInterval; ConfigureEncryption(); ConfigureCompression(); if (_channelFactory == null) { throw new ApplicationException(LanguageResource.ApplicationException_NoChannelFactorySpecified); } channel = _channelFactory(_channelSettings, BuildClientSinkChain(), BuildServerSinkChain()); RemotingHelper.ResetCustomErrorsMode(); } return(channel); }
/// <summary> /// Creates and configures a Remoting channel. /// </summary> /// <returns>Remoting channel</returns> public override IChannel CreateChannel() { IChannel channel = ChannelServices.GetChannel(_channelName); if (channel == null) { _channelSettings["name"] = _channelName; _channelSettings["port"] = 0; _channelSettings["socketCacheTimeout"] = 0; _channelSettings["socketCachePolicy"] = SocketCachingEnabled ? SocketCachePolicy.Default : SocketCachePolicy.AbsoluteTimeout; _channelSettings["secure"] = false; ConfigureEncryption(); ConfigureCompression(); if (_channelFactory == null) { throw new ApplicationException(LanguageResource.ApplicationException_NoChannelFactorySpecified); } channel = _channelFactory(_channelSettings, BuildClientSinkChain(), BuildServerSinkChain()); RemotingHelper.ResetCustomErrorsMode(); } return(channel); }
public static void Unregister(Type objectType, string label = null, bool ignoreCase = false) { string objectUri = GetObjectUri(objectType, label, ignoreCase); try { lock (SyncRoot) { IChannel channel = ChannelServices.GetChannel(objectUri); if (channel != null) { Type remotingConfigHandlerType = Type.GetType("System.Runtime.Remoting.RemotingConfigHandler, mscorlib"); FieldInfo remotingConfigHandlerFieldInfoInfo = remotingConfigHandlerType.GetField("Info", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static); Type identityHolderType = Type.GetType("System.Runtime.Remoting.IdentityHolder, mscorlib"); MethodInfo identityHolderMethodInfoRemoveIdentity = identityHolderType.GetMethod("RemoveIdentity", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Static, null, new Type[] { typeof(string) }, null); object obj = remotingConfigHandlerFieldInfoInfo.GetValue(null); FieldInfo fieldInfo = obj.GetType().GetField("_wellKnownExportInfo", BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance); obj = fieldInfo.GetValue(obj); Hashtable registeredTypes = (Hashtable)obj; try { identityHolderMethodInfoRemoveIdentity.Invoke(null, new object[] { objectUri }); registeredTypes.Remove(objectUri.ToLowerInvariant()); } catch { } IpcChannel ipcChannel = channel as IpcChannel; if (ipcChannel != null) { ipcChannel.StopListening(null); } IpcServerChannel ipcServerChannel = channel as IpcServerChannel; if (ipcServerChannel != null) { ipcServerChannel.StopListening(null); } ChannelServices.UnregisterChannel(channel); } } } catch (RemotingException) { } catch (Exception e) { InternalLogger.Log(e); throw; } }
private void btnStop_Click(object sender, EventArgs e) { if (ChannelServices.GetChannel("tcp") != null) { ChannelServices.UnregisterChannel(tcpChannel); txtStatus.Text = "Stop in Port: " + port.ToString() + " at: " + DateTime.Now.ToString(); } }
public static void Disconnect(ServiceInterface serviceInterface) { RemotingServices.Disconnect(serviceInterface); var Channel = ChannelServices.GetChannel("FileWallChannel"); ChannelServices.UnregisterChannel(Channel); }
private void UnRegisterObject() { //IChannel[] lArrObjRegistedChannels = ChannelServices.RegisteredChannels; //IChannel lObjChannel = (IChannel)ChannelServices.GetChannel(lArrObjRegistedChannels[0].ChannelName); IChannel lObjChannel = (IChannel)ChannelServices.GetChannel(GetChannelName()); ChannelServices.UnregisterChannel(lObjChannel); }
void UnregisterAllIPCChannels() { if (ChannelServices.RegisteredChannels.Length > 0) { ChannelServices.UnregisterChannel(ChannelServices.GetChannel(ChannelServices.RegisteredChannels[0].ChannelName)); UnregisterAllIPCChannels(); } }
public void Connect() { if (ChannelServices.GetChannel(tcpClient.ChannelName) == null) { ChannelServices.RegisterChannel(tcpClient, false); } ActivateObjects(); }
//remove channel if it exists public static void RemoveChannel(string name) { var ch = ChannelServices.GetChannel(name); if (ch != null) { ChannelServices.UnregisterChannel(ch); } }
/// <summary> /// Registers IPC Client Channel. /// </summary> /// <param name="channelName"></param> /// <param name="port"></param> public void RegisterIPCClientChannel(string channelName) { _ipcClientChannel = ChannelServices.GetChannel(channelName); if (_ipcClientChannel == null) { BinaryClientFormatterSinkProvider cprovider = new BinaryClientFormatterSinkProvider(); _ipcClientChannel = new IpcClientChannel(channelName, cprovider); ChannelServices.RegisterChannel(_ipcClientChannel); } }
public RemoteTracerServer() { IChannel clientChannel = ChannelServices.GetChannel("tcp"); if (clientChannel == null) { ChannelServices.RegisterChannel(new TcpClientChannel(), false); } ListenerUrl = "tcp://localhost:15456/RemoteListener"; }
/// <summary> /// Registers IPC server channel. /// </summary> /// <param name="channelName"></param> /// <param name="port"></param> public void RegisterIPCServerChannel(string channelName, string portName) { _ipcServerChannel = ChannelServices.GetChannel(channelName); if (_ipcServerChannel == null) { BinaryServerFormatterSinkProvider sprovider = new BinaryServerFormatterSinkProvider(); sprovider.TypeFilterLevel = TypeFilterLevel.Full; _ipcServerChannel = new IpcServerChannel(channelName, portName, sprovider);; ChannelServices.RegisterChannel(_ipcServerChannel); } }
/// <summary> /// /// </summary> /// <param name="channelName"></param> /// <param name="port"></param> public void RegisterHttpServerChannel(string channelName, int port) { _httpServerChannel = ChannelServices.GetChannel(channelName); if (_httpServerChannel == null) { BinaryServerFormatterSinkProvider sprovider = new BinaryServerFormatterSinkProvider(); sprovider.TypeFilterLevel = TypeFilterLevel.Full; _httpServerChannel = new HttpServerChannel(channelName, port, sprovider); ChannelServices.RegisterChannel(_httpServerChannel); } }
private static void InitializeIpc() { AgentChannel = ChannelServices.GetChannel("LagfreeAgentClient") as IpcClientChannel; if (AgentChannel == null) { AgentChannel = new IpcClientChannel("LagfreeAgentClient", null); ChannelServices.RegisterChannel(AgentChannel, true); } RemotingConfiguration.RegisterWellKnownClientType(typeof(VisiblePids), "ipc://LagfreeAgent/VisiblePids"); ForegroundPids = new VisiblePids(); }
/// <summary> /// Constructs ChatRoom instance. /// </summary> public ChatRoom() { //*** Send the event via IP multicast to the specific court IBroadcastSenderProvider iBroadcastSenderProvider = ChannelServices.GetChannel("BroadcastSender") as IBroadcastSenderProvider; this._dispatcher.Add(iBroadcastSenderProvider.GetBroadcastSender("/Chat/GlobalRoom")); // bind server's methods this._dispatcher.BroadcastCallFinishedHandler += new BroadcastCallFinishedHandler(this.BroadcastCallFinishedHandler); this._dispatcher.CallIsAsync = true; }
public virtual void ClientDisconnect() { var channel = ChannelServices.GetChannel("FileWallChannel2"); if (channel == null) { throw new InvalidOperationException("Error while disconnecting IPC port. Can't find FileWallChannel2."); } ChannelServices.UnregisterChannel(channel); }
/// <summary> /// /// </summary> /// <param name="channelName"></param> /// <param name="port"></param> public void RegisterHttpClientChannel(string channelName) { #if !NETCORE _httpClientChannel = ChannelServices.GetChannel(channelName); if (_httpClientChannel == null) { BinaryClientFormatterSinkProvider cprovider = new BinaryClientFormatterSinkProvider(); _httpClientChannel = new HttpClientChannel(channelName, cprovider); ChannelServices.RegisterChannel(_httpClientChannel); } #endif }
public override void Initialize() { // Channel already open? _channel = ChannelServices.GetChannel(RemotingReceiverChannelName); if (_channel == null) { // Allow clients to receive complete Remoting exception information if (RemotingConfiguration.CustomErrorsEnabled(true)) { RemotingConfiguration.CustomErrorsMode = CustomErrorsModes.Off; } // Create TCP Channel try { BinaryClientFormatterSinkProvider clientProvider = null; var serverProvider = new BinaryServerFormatterSinkProvider { TypeFilterLevel = TypeFilterLevel.Full }; IDictionary props = new Hashtable(); props["port"] = Port.ToString(); props["name"] = RemotingReceiverChannelName; props["typeFilterLevel"] = TypeFilterLevel.Full; _channel = new TcpChannel(props, clientProvider, serverProvider); ChannelServices.RegisterChannel(_channel, false); } catch (Exception ex) { throw new Exception("Remoting TCP Channel Initialization failed", ex); } } var serverType = RemotingServices.GetServerTypeForUri(SinkName); if (serverType == null || serverType != typeof(RemotingAppender.IRemoteLoggingSink)) // Marshal Receiver { try { RemotingServices.Marshal(this, SinkName, typeof(RemotingAppender.IRemoteLoggingSink)); } catch (Exception ex) { throw new Exception("Remoting Marshal failed", ex); } } }
public void TryRegisterClientChannel() { Uri uri = GetUriFromAddressBase(); logger.DebugFormat("Creating client channel for URI {0}...", uri); var handler = ChannelSelector.Do.GetHandler(uri); if (ChannelServices.GetChannel(handler.DefaultName) == null) { ChannelServices.RegisterChannel(handler.CreateClientChannel(), false); } }