private static void CreateChannel() { var type = typeof(Type); foreach (var entry in RemotingConfiguration.GetRegisteredWellKnownServiceTypes()) { if (entry.ObjectType == type) { return; } } var portName = $"{AppDomain.CurrentDomain.FriendlyName.Replace(".", "-").ToLower()}-{Process.GetCurrentProcess().Id}"; var objectUri = type.Name.ToLower(); var client = new BinaryClientFormatterSinkProvider(); var server = new BinaryServerFormatterSinkProvider { TypeFilterLevel = TypeFilterLevel.Full }; var config = new Hashtable { ["name"] = string.Empty, ["portName"] = portName, ["tokenImpersonationLevel"] = TokenImpersonationLevel.Impersonation, ["impersonate"] = true, ["useDefaultCredentials"] = true, ["secure"] = true, ["typeFilterLevel"] = TypeFilterLevel.Full }; var ipcChannel = new IpcChannel(config, client, server); ChannelServices.RegisterChannel(ipcChannel, true); RemotingConfiguration.RegisterWellKnownServiceType(type, objectUri, WellKnownObjectMode.SingleCall); }
// This function iterates through all the WellKnownService types // that were loaded via the RemotingConfiguration.Configure(Remoting.config) // file. private void ListWellKnownServiceTypes() { foreach (WellKnownServiceTypeEntry entry in RemotingConfiguration.GetRegisteredWellKnownServiceTypes()) { this.lstOutput.Items.Add(entry.TypeName + " is available at " + entry.ObjectUri); } }
public static void Main() { // Create a 'HttpChannel' object and register it with the // channel services. ChannelServices.RegisterChannel(new HttpChannel(8086)); // Record the 'HelloServer' type as 'Singleton' well-known type. WellKnownServiceTypeEntry myWellKnownServiceTypeEntry = new WellKnownServiceTypeEntry(typeof(HelloServer), "SayHello", WellKnownObjectMode.Singleton); // Register the remote object as well-known type. RemotingConfiguration.RegisterWellKnownServiceType( myWellKnownServiceTypeEntry); // Retrieve object types registered on the service end // as well-known types. WellKnownServiceTypeEntry [] myWellKnownServiceTypeEntryCollection = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); Console.WriteLine("The 'WellKnownObjectMode' of the remote object : " + myWellKnownServiceTypeEntryCollection[0].Mode); Console.WriteLine("The 'WellKnownServiceTypeEntry' object: " + myWellKnownServiceTypeEntryCollection[0].ToString()); Console.WriteLine("Started the Server, Hit <enter> to exit..."); Console.ReadLine(); }
static void Main(string[] args) { RemotingConfiguration.Configure(CONFIG_FILE, false); var clients = RemotingConfiguration.GetRegisteredWellKnownClientTypes(); if (clients.Length == 0) { Console.WriteLine("You must specify app.config file with wellknown tag inside a client tag."); Console.ReadLine(); return; } var services = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); if (services.Length == 0) { Console.WriteLine("You must specify app.config file with wellknown tag inside a service tag."); Console.ReadLine(); return; } var central = (ICentralManager)Activator.GetObject(clients[0].ObjectType, clients[0].ObjectUrl); var broker = new Broker(central); ObjRef objrefWellKnown = RemotingServices.Marshal(broker, services[0].ObjectUri); Console.WriteLine("Início do Server Broker.\n Espera de pedidos"); Console.ReadLine(); }
/// <summary> /// Initializes communications with the outside world by means of remoting /// </summary> private void InitializeRemotingCommunications() { // Read the configuration file. RemotingConfiguration.Configure("..\\..\\App.config", false); WellKnownServiceTypeEntry[] wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); // "Activate" the NameService singleton. objectDirectory = (ObjectDirectory)Activator.GetObject(typeof(ObjectDirectory), wkst[0].ObjectUri); // Bind the operational test faceade objectDirectory.Rebind(this, "OperationalTestFacade"); // Retreive the directory of messaging channels IChannelFactory channelFactory = (IChannelFactory)objectDirectory.Resolve("ChannelFactory"); // Retreive the Messaging Service channels we want to listen to rndfChannel = channelFactory.GetChannel("RndfNetworkChannel", ChannelMode.Bytestream); mdfChannel = channelFactory.GetChannel("MdfChannel", ChannelMode.Bytestream); positionChannel = channelFactory.GetChannel("PositionChannel", ChannelMode.Bytestream); testStringChannel = channelFactory.GetChannel("TestStringChannel", ChannelMode.Vanilla); // Create a channel listeners and listen on wanted channels channelListener = new MessagingListener(); rndfToken = rndfChannel.Subscribe(channelListener); mdfToken = mdfChannel.Subscribe(channelListener); //positionToken = positionChannel.Subscribe(channelListener); testStringToken = testStringChannel.Subscribe(new StringListener()); // Show that the navigation system is ready and waiting for input Console.WriteLine(" > Remoting Communication Initialized"); }
static void Main(string[] args) { Console.WriteLine("***** SimpleRemoteObjectServer started! *****"); Console.WriteLine("Hit enter to end."); RemotingConfiguration.ApplicationName = "First server app!"; // Create a new HttpChannel HttpChannel c = new HttpChannel(32469); ChannelServices.RegisterChannel(c); // Register a 'well-known' object. RemotingConfiguration.RegisterWellKnownServiceType( typeof(SimpleRemotingAsm.RemoteMessageObject), "RemoteMsgObj.soap", WellKnownObjectMode.SingleCall); #region Fun with registration services. Console.WriteLine("App Name: {0}", RemotingConfiguration.ApplicationName); WellKnownServiceTypeEntry[] WKOs = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); foreach (WellKnownServiceTypeEntry wko in WKOs) { Console.WriteLine("Asm name containing WKO: {0}", wko.AssemblyName); Console.WriteLine("URL to WKO: {0}", wko.ObjectUri); Console.WriteLine("Type of WKO: {0}", wko.ObjectType); Console.WriteLine("Mode of WKO: {0}", wko.Mode); } #endregion Console.ReadLine(); }
public static void Main() { // <Snippet1> // Configure the remoting structure. RemotingConfiguration.Configure("server.config"); // </Snippet1> // <Snippet2> // Retrive the array of objects registered as well known types at // the service end. WellKnownServiceTypeEntry[] myEntries = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); Console.WriteLine("The number of WellKnownServiceTypeEntries are:" + myEntries.Length); Console.WriteLine("The Object Type is:" + myEntries[0].ObjectType); Console.WriteLine("The Object Uri is:" + myEntries[0].ObjectUri); Console.WriteLine("The Mode is:" + myEntries[0].Mode); // </Snippet2> Console.WriteLine("Press <enter> to exit..."); Console.ReadLine(); }
/// <summary> /// Registers the bootstrap remoting access service. /// </summary> protected virtual void RegisterRemotingService() { var bootstrapIpcPort = string.Format("SuperSocket.Bootstrap[{0}]", Math.Abs(AppDomain.CurrentDomain.BaseDirectory.TrimEnd(System.IO.Path.DirectorySeparatorChar).GetHashCode())); var serverChannelName = "Bootstrap"; var serverChannel = ChannelServices.RegisteredChannels.FirstOrDefault(c => c.ChannelName == serverChannelName); if (serverChannel != null) { ChannelServices.UnregisterChannel(serverChannel); } serverChannel = new IpcServerChannel(serverChannelName, bootstrapIpcPort); ChannelServices.RegisterChannel(serverChannel, false); AppDomain.CurrentDomain.SetData("BootstrapIpcPort", bootstrapIpcPort); var bootstrapProxyType = typeof(RemoteBootstrapProxy); if (!RemotingConfiguration.GetRegisteredWellKnownServiceTypes().Any(s => s.ObjectType == bootstrapProxyType)) { RemotingConfiguration.RegisterWellKnownServiceType(bootstrapProxyType, "Bootstrap.rem", WellKnownObjectMode.Singleton); } }
static void Main(string[] args) { RemotingConfiguration.Configure(CONFIG_FILE, false); var services = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); if (services.Length == 0) { Console.WriteLine("You must specify app.config file with wellknown tag inside a service tag."); Console.ReadLine(); return; } var config = ConfigurationSettings.AppSettings; var type = config["type"]; var assembly = config["assembly"]; var brokers = new List <IBrokerClient>(); for (int i = 2; i < config.Count; i++) { WellKnownClientTypeEntry entry = new WellKnownClientTypeEntry(type, assembly, config[i]); brokers.Add((IBrokerClient)Activator.GetObject(entry.ObjectType, entry.ObjectUrl)); } var central = new CentralManager(brokers); ObjRef objrefWellKnown = RemotingServices.Marshal(central, services[0].ObjectUri); Console.WriteLine("Início do Server CentralManager.\n Espera de pedidos"); Console.ReadLine(); }
public void RegisterWellKnownType() { TcpChannel chn = null; try { chn = new TcpChannel(1234); ChannelServices.RegisterChannel(chn); // register the SAO if(RemotingConfiguration.ApplicationName == null) RemotingConfiguration.ApplicationName = "RemotingConfigurationTest"; RemotingConfiguration.RegisterWellKnownServiceType(typeof(DerivedWellKnownObject), "WellKnownObject.rem", WellKnownObjectMode.Singleton); // get the registered services WellKnownServiceTypeEntry[] ast = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); bool IsServerRegistered = false; foreach(WellKnownServiceTypeEntry aste in ast) { if(aste.ObjectType == typeof(DerivedWellKnownObject)) { IsServerRegistered = true; break; } } Assert.IsTrue(IsServerRegistered, "#A02"); // register the client RemotingConfiguration.RegisterWellKnownClientType(typeof(WellKnownObject), "tcp://localhost:1234/"+RemotingConfiguration.ApplicationName+"/WellKnownObject.rem"); // get the registered client WellKnownClientTypeEntry[] act = RemotingConfiguration.GetRegisteredWellKnownClientTypes(); bool IsClientRegistered = false; foreach(WellKnownClientTypeEntry acte in act) { if(acte.ObjectType == typeof(WellKnownObject)) { IsClientRegistered = true; break; } } Assert.IsTrue(IsClientRegistered, "#A03"); WellKnownObject objWellKnown = new WellKnownObject(); Assert.IsTrue(objWellKnown != null, "#A04"); Assert.IsTrue(RemotingServices.IsTransparentProxy(objWellKnown), "#A05"); objWellKnown.Method1(); Assert.IsTrue(objWellKnown.Method1Called, "#A06"); } finally { ChannelServices.UnregisterChannel(chn); } }
public void RefreshService() { lstBoxService.Items.Clear(); foreach (WellKnownServiceTypeEntry w in RemotingConfiguration.GetRegisteredWellKnownServiceTypes()) { lstBoxService.Items.Add(w); } }
public static void MostrarTodosLosDatos() { Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(INICIO)- ---------"); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedClientTypes()); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedServiceTypes()); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownClientTypes()); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownServiceTypes()); Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(FIN)- ---------"); }
private static int ServerMain(string[] args) { var configFilename = Path.Combine(Path.GetDirectoryName(typeof(ServerService).Assembly.Location) ?? throw new InvalidOperationException(), "server.config"); RemotingConfiguration.Configure(configFilename, false); var x = ChannelServices.RegisteredChannels; var y = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); return(0); }
public static void DumpAllInfoAboutRegisteredRemotingTypes() { Log.Print("ALL REGISTERED TYPES IN REMOTING -(BEGIN)---------"); DumpTypeEntries(RemotingConfiguration.GetRegisteredActivatedClientTypes()); DumpTypeEntries(RemotingConfiguration.GetRegisteredActivatedServiceTypes()); DumpTypeEntries(RemotingConfiguration.GetRegisteredWellKnownClientTypes()); DumpTypeEntries(RemotingConfiguration.GetRegisteredWellKnownServiceTypes()); Log.Print("ALL REGISTERED TYPES IN REMOTING -(END) ---------"); }
private static void ShowWellKnownServiceTypes() { WellKnownServiceTypeEntry[] serviceTypeEntries = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); foreach (WellKnownServiceTypeEntry typeEntry in serviceTypeEntries) { Console.WriteLine("Assembly: {0}", typeEntry.AssemblyName); Console.WriteLine("Mode: {0}", typeEntry.Mode); Console.WriteLine("URI: {0}", typeEntry.ObjectUri); Console.WriteLine("Type: {0}", typeEntry.TypeName); } }
/// <summary> /// 取得远程类信息 /// </summary> /// <returns></returns> public static string[] GetRemotingEntries() { WellKnownServiceTypeEntry[] entries = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); string[] types = new string[entries.Length]; for (int index = 0; index < entries.Length; ++index) { types[index] = entries[index].TypeName; } return(types); }
//Metodo de impresion de datos public static void MostrarTodosLosDatos() { Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(INICIO)- --------"); //Recupera una matriz de tipos de objetos registrados en el extremo de servicios //que puede activarse a petición de un cliente. MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedClientTypes()); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedServiceTypes()); //Recupera una matriz de tipos de objetos registrados en el cliente final como tipos conocidos. MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownClientTypes()); MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownServiceTypes()); Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(FIN)- ---------"); }
/// <summary> /// Configures remoting /// </summary> public void Configure() { try { // configure RemotingConfiguration.Configure("SimulatorClient.exe.config", false); wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); } catch (Exception e) { Console.WriteLine(DateTime.Now.ToString() + ": Error Configuring Remoting: " + e.ToString()); } }
private static void printRemoteConfig(System.IO.TextWriter writer) { foreach (var channel in ChannelServices.RegisteredChannels) { writer.WriteLine($"Channel {channel.ToString()} registered"); } var services = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); foreach (var service in services) { writer.WriteLine($"Registered {service.TypeName} as {service.Mode} on uri {service.ObjectUri}"); } }
private static void instantiateSingletonServer() { var type = RemotingConfiguration.GetRegisteredWellKnownServiceTypes()[0]; var channel = ChannelServices.RegisteredChannels[0]; string uri = String.Format("{0}://127.0.0.1:{1}/{2}", ConfigurationManager.AppSettings["Channel"], ConfigurationManager.AppSettings["Port"], type.ObjectUri); instance = (IServerExtended)Activator.GetObject(typeof(IServerExtended), uri); instance.SendMessage(String.Format("Singleton Created on port channel {0} and port {1}", ConfigurationManager.AppSettings["Channel"], ConfigurationManager.AppSettings["Port"])); instance.Start(); }
// Método que recupera la información acerca del tipo de los objetos definidos, configurados // para el programa que usa net remoting public static void MostrarTodosLosDatos() { Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(INICIO)- ---------"); // Recupera los tipos de objetos registrados en el cliente como tipos que se activarán // de forma remota MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedClientTypes()); // Recupera los tipos de objetos registrados en el servicio que se pueden activar // cuando lo solicita un cliente. MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedServiceTypes()); // Recupera los tipos de objetos registrados en el cliente como tipos conocidos (WellKnown) MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownClientTypes()); // Recupera los tipos de objetos registrados en el servicio como tipos conocidos (WellKnown) MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownServiceTypes()); Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(FIN)- ---------"); }
/// Metodo MostrarTodosLosDatos public static void MostrarTodosLosDatos() { //Llamada al metodo Imprimir de la clase Log Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTING -(INICIO)- ----------"); //llamada al metodo MostrarTipoDeDatos que obtiene los tipos de datos de la comunicacion remota MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedClientTypes()); //llamada al metodo MostrarTipoDeDatos que obtiene los tipos de datos de la comunicacion remota MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredActivatedServiceTypes()); //llamada al metodo MostrarTipoDeDatos que obtiene los tipos de datos de la comunicacion remota MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownClientTypes()); //llamada al metodo MostrarTipoDeDatos que obtiene los tipos de datos de la comunicacion remota MostrarTipoDeDatos(RemotingConfiguration.GetRegisteredWellKnownServiceTypes()); //Llamada al metodo Imprimir de la clase Log Log.Imprimir("TIPOS DE DATOS REGISTRADOS EN REMOTIN -(FIN)- ----------"); }
public static void InitComm() { // set the machine name from the config machineName = Properties.Settings.Default.MachineName.Trim().ToUpper(); // configure remoting RemotingConfiguration.Configure("net.xml", false); // get the name service WellKnownServiceTypeEntry[] wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); objectDirectory = (ObjectDirectory)Activator.GetObject(typeof(ObjectDirectory), wkst[0].ObjectUri); // get the channel factory channelFactory = (IChannelFactory)objectDirectory.Resolve("ChannelFactory"); }
public static bool DoesWellKnowServiceExist(string ServiceName) { bool RetVal = false; WellKnownServiceTypeEntry[] ExistingServices = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); foreach (WellKnownServiceTypeEntry Service in ExistingServices) { if (Service.ObjectUri == ServiceName) { RetVal = true; break; } } return(RetVal); }
public static void ConfigureRemoting(string server) { RemotingConfiguration.Configure("net.xml", false); if (!string.IsNullOrEmpty(server)) { string uri = "tcp://" + server + ":12345/ObjectDirectory"; od = (ObjectDirectory)Activator.GetObject(typeof(ObjectDirectory), uri); } else { WellKnownServiceTypeEntry[] wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); // "Activate" the NameService singleton. od = (ObjectDirectory)Activator.GetObject(typeof(ObjectDirectory), wkst[0].ObjectUri); } }
private static bool ExistServiceType(string typeName, ref string url) { typeName = typeName.Trim(); WellKnownServiceTypeEntry[] entries = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); for (int i = 0; i < entries.Length; i++) { if (entries[i].TypeName == typeName) { url = entries[i].ObjectUri; return(true); } } return(false); //Not found }
/// <summary> /// Configures remoting /// </summary> public void Configure() { try { // configure RemotingConfiguration.Configure("Simulator.exe.config", false); wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); // notfy SimulatorOutput.WriteLine("Remoting Configured Successfully"); } catch (Exception e) { SimulatorOutput.WriteLine("Error Configuring Remoting: " + e.ToString()); } }
public static String GetTypeName( String Uri) { WellKnownServiceTypeEntry[] svcTypes = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); foreach (WellKnownServiceTypeEntry svcType in svcTypes) { if (Uri.Equals("/" + svcType.ObjectUri)) { // we need to pass type of service to deserializer and Type.GetType // requires assembly qualified name return(svcType.ObjectType.AssemblyQualifiedName); } } throw new Exception("couldn't find type"); }
static void Main(string[] args) { // Read the configuration file. RemotingConfiguration.Configure("..\\..\\ProxyService.exe.config", false); WellKnownServiceTypeEntry[] wkst = RemotingConfiguration.GetRegisteredWellKnownServiceTypes(); // "Activate" the NameService singleton. ObjectDirectory od = (ObjectDirectory)Activator.GetObject(typeof(ObjectDirectory), wkst[0].ObjectUri); // Bind the facades of components we implement. od.Rebind(Arbiter.FacadeImpl.Instance, "Arbiter"); Console.WriteLine("Waiting"); // Enter the main event loop... Console.ReadLine(); }
public static void Main(String[] args) { Console.ForegroundColor = ConsoleColor.Green; Console.WriteLine("---------------------------------"); Console.WriteLine("WARNING ! XEN SERVER UNLEASHED !"); Console.WriteLine("---------------------------------"); try { TcpChannel channel = new TcpChannel(2019); ChannelServices.RegisterChannel(channel, false); RemotingConfiguration.RegisterWellKnownServiceType(typeof(ServiceAuthentification), "ServiceAuthentification", WellKnownObjectMode.Singleton); RemotingConfiguration.RegisterWellKnownServiceType(typeof(MachineManagerService), "MachineManagerService", WellKnownObjectMode.Singleton); RemotingConfiguration.RegisterWellKnownServiceType(typeof(ClientManagerService), "ClientManagerService", WellKnownObjectMode.Singleton); RemotingConfiguration.RegisterWellKnownServiceType(typeof(FactureManagerService), "FactureManagerService", WellKnownObjectMode.Singleton); Trace.TraceInformation("Started server On " + DateTime.Now.ToString()); Trace.Listeners.Add(new TextWriterTraceListener(Console.Out)); Trace.AutoFlush = true; Console.WriteLine("RegisteredTypes : "); foreach (WellKnownServiceTypeEntry obj in RemotingConfiguration.GetRegisteredWellKnownServiceTypes()) { Console.WriteLine("Object : " + obj.ObjectType); } Console.WriteLine("---------------------------"); Console.WriteLine(""); System.Console.WriteLine("Server Running ..."); while (true) { } } catch (Exception e) { Trace.TraceError("Server crash On : " + DateTime.Now.ToString()); Trace.WriteLine(e.StackTrace); System.Console.WriteLine("Server Runtime Exception ..."); System.Console.WriteLine(e.Message); } }