internal static core.v2_0.services.access_control.CallChain UnmarshalLegacyCallChain(SignedCallChain signed) { TypeCode chainTypeCode = OrbServices.GetSingleton().create_tc_for_type(typeof(core.v2_0.services.access_control.CallChain)); return((core.v2_0.services.access_control.CallChain)InterceptorsInitializer.Codec.decode_value(signed.encoded, chainTypeCode)); }
public void ShareDataKeys(List <byte[]> keys) { omg.org.CORBA.TypeCode byteTC = OrbServices.GetSingleton().create_octet_tc(); omg.org.CORBA.TypeCode sequenceTC = OrbServices.GetSingleton().create_sequence_tc(0, byteTC); omg.org.CORBA.TypeCode arrayTC = OrbServices.GetSingleton().create_array_tc(keys.Count, sequenceTC); Share(new Any(keys.ToArray(), arrayTC)); }
static void Main() { log4net.Config.XmlConfigurator.Configure(); OrbServices.CreateAndRegisterIiopChannel(0); String componentModel = Resources.ComponentDesc; TextReader file = new StringReader(componentModel); XmlTextReader componentInformation = new XmlTextReader(file); XmlComponentBuilder builder = new XmlComponentBuilder(componentInformation); ComponentContext pingContext = builder.build(); //Escrevendo a IOR do IComponent no arquivo. IComponent pingComponent = pingContext.GetIComponent(); OrbServices orb = OrbServices.GetSingleton(); String ior = orb.object_to_string(pingComponent); String iorPath = Resources.IorFilename; StreamWriter stream = new StreamWriter(iorPath); try { stream.Write(ior); } finally { stream.Close(); } Console.WriteLine("Componente ping está no ar."); Console.ReadLine(); }
public void TestSlotModifyInClientRecContextAndServer() { try { int slotId = m_testInterceptorInit.RequestIntercept.SlotId; ORB orb = OrbServices.GetSingleton(); omg.org.PortableInterceptor.Current current = (omg.org.PortableInterceptor.Current)orb.resolve_initial_references("PICurrent"); int contextEntryVal = 4; current.set_slot(slotId, contextEntryVal); System.Int32 arg = 1; System.Int32 result = m_testService.TestAddToContextData(arg); Assertion.AssertEquals(arg + contextEntryVal, result); Assertion.Assert("service context not present", m_testInterceptorInit.RequestIntercept.HasReceivedContextElement); Assertion.AssertEquals("service context content", arg + contextEntryVal, m_testInterceptorInit.RequestIntercept.ContextElement.TestEntry); current = (omg.org.PortableInterceptor.Current)orb.resolve_initial_references("PICurrent"); Assertion.AssertEquals("slot was modified", contextEntryVal, current.get_slot(slotId)); } finally { m_testInterceptorInit.RequestIntercept.ClearInvocationHistory(); } }
public void SetUp() { m_orb = OrbServices.GetSingleton(); m_channel = new IiopChannel(TEST_PORT); ChannelServices.RegisterChannel(m_channel, false); }
private void IntializeForInterception(IInterceptionOption[] interceptionOptions) { // flow lifetime is bound to message lifetime, GiopClientRequest is only a wrapper around message and // can be recreated during message lifetime. m_interceptionFlow = (ClientRequestInterceptionFlow)SimpleGiopMsg.GetInterceptionFlow(m_requestMessage); if (m_interceptionFlow == null) { ClientRequestInterceptor[] interceptors = OrbServices.GetSingleton().InterceptorManager.GetClientRequestInterceptors(interceptionOptions); if (interceptors.Length == 0) { m_interceptionFlow = new ClientRequestInterceptionFlow(); } else { m_interceptionFlow = new ClientRequestInterceptionFlow(interceptors); } SimpleGiopMsg.SetInterceptionFlow(m_requestMessage, m_interceptionFlow); } if (m_interceptionFlow.NeedsRequestInfo()) { // optimization: needs not be created, if non-intercepted. m_clientRequestInfo = new ClientRequestInfoImpl(this); } }
static void Main() { Console.WriteLine("Pressione 'enter' quando o componente Hello estiver no ar."); Console.ReadLine(); OrbServices.CreateAndRegisterIiopChannel(); String helloIorPath = Resources.IorFilename; StreamReader stream = new StreamReader(helloIorPath); String helloIor; try { helloIor = stream.ReadToEnd(); } finally { stream.Close(); } OrbServices orb = OrbServices.GetSingleton(); IComponent icomponent = orb.string_to_object(helloIor) as IComponent; Hello hello = icomponent.getFacetByName("Hello") as Hello; hello.sayHello(); Console.ReadLine(); }
public static void Main(String[] args) { IOrbServices orb = OrbServices.GetSingleton(); TestInterceptorInit testInterceptorInit = new TestInterceptorInit(); orb.RegisterPortableInterceptorInitalizer(testInterceptorInit); // register the channel int port = 8087; IiopChannel chan = new IiopChannel(port); ChannelServices.RegisterChannel(chan, false); orb.CompleteInterceptorRegistration(); TestInterceptorControlService controlService = new TestInterceptorControlService(testInterceptorInit); string objectURIControlService = "interceptorControl"; RemotingServices.Marshal(controlService, objectURIControlService); TestService test = new TestService(); string objectURI = "test"; RemotingServices.Marshal(test, objectURI); Console.WriteLine("server running"); Thread.Sleep(Timeout.Infinite); }
internal static CallChain UnmarshalCallChain(SignedData signed) { TypeCode chainTypeCode = OrbServices.GetSingleton().create_tc_for_type(typeof(CallChain)); return((CallChain)InterceptorsInitializer.Codec.decode_value(signed.encoded, chainTypeCode)); }
private static void Main() { Assembly.Load("OpenBus.Legacy.Idl"); string hostName = DemoConfig.Default.busHostName; ushort hostPort = DemoConfig.Default.busHostPort; string loginFile = DemoConfig.Default.loginFile; bool useSSL = DemoConfig.Default.useSSL; string clientUser = DemoConfig.Default.clientUser; string clientThumbprint = DemoConfig.Default.clientThumbprint; string serverUser = DemoConfig.Default.serverUser; string serverThumbprint = DemoConfig.Default.serverThumbprint; ushort serverSSLPort = DemoConfig.Default.serverSSLPort; ushort serverOpenPort = DemoConfig.Default.serverOpenPort; string busIORFile = DemoConfig.Default.busIORFile; if (useSSL) { Utils.InitSSLORB(clientUser, clientThumbprint, serverUser, serverThumbprint, serverSSLPort, serverOpenPort, true, true, "required", false, false); } else { ORBInitializer.InitORB(); } /* * ConsoleAppender appender = new ConsoleAppender { * Threshold = Level.Off, * Layout = * new SimpleLayout(), * }; * BasicConfigurator.Configure(appender); */ ConnectionProperties props = new ConnectionPropertiesImpl(); OpenBusContext context = ORBInitializer.Context; Connection conn; if (useSSL) { string ior = File.ReadAllText(busIORFile); conn = context.ConnectByReference((MarshalByRefObject)OrbServices.CreateProxy(typeof(MarshalByRefObject), ior), props); } else { conn = context.ConnectByAddress(hostName, hostPort, props); } context.SetDefaultConnection(conn); byte[] encoded = File.ReadAllBytes(loginFile); SharedAuthSecret secret = context.DecodeSharedAuth(encoded); conn.LoginBySharedAuth(secret); Assert.IsNotNull(conn.Login); Assert.IsNotNull(conn.Login.Value.id); Assert.IsNotNull(conn.Login.Value.entity); conn.Logout(); Logger.Info("Fim."); }
private void RegisterInterceptors() { IOrbServices orb = OrbServices.GetSingleton(); m_testInterceptorInit = new TestInterceptorInit(); orb.RegisterPortableInterceptorInitalizer(m_testInterceptorInit); orb.CompleteInterceptorRegistration(); }
public bool NoValueInScope() { ORB orb = OrbServices.GetSingleton(); omg.org.PortableInterceptor.Current current = (omg.org.PortableInterceptor.Current)orb.resolve_initial_references("PICurrent"); return(current.get_slot(m_slotId) == null); }
public string fetchHello(byte[] encodedChain) { OpenBusContext context = ORBInitializer.Context; CallerChain chain; try { chain = context.DecodeChain(encodedChain); } catch (InvalidEncodedStreamException e) { Console.WriteLine(e); throw new ArgumentException("Cadeia em formato inválido.", e); } context.JoinChain(chain); ServiceProperty[] properties = { new ServiceProperty("offer.domain", "Interoperability Tests"), new ServiceProperty("openbus.component.interface", Repository.GetRepositoryID(typeof(Hello))), new ServiceProperty("openbus.component.name", "RestrictedHello") }; List <ServiceOfferDesc> offers = Utils.FindOffer(ORBInitializer.Context.OfferRegistry, properties, 1, 10, 1); foreach (ServiceOfferDesc desc in offers) { try { if (OrbServices.GetSingleton().non_existent(desc.service_ref)) { continue; } } catch (TRANSIENT) { continue; } catch (COMM_FAILURE) { continue; } MarshalByRefObject helloObj = desc.service_ref.getFacet(Repository.GetRepositoryID(typeof(Hello))); if (helloObj == null) { Console.WriteLine( "Não foi possível encontrar uma faceta com esse nome."); continue; } Hello hello = helloObj as Hello; if (hello == null) { Console.WriteLine("Faceta encontrada não implementa Hello."); continue; } return(hello.sayHello()); } return(""); }
private static CredentialData UnmarshalCredential(ServiceContext serviceContext) { OrbServices orb = OrbServices.GetSingleton(); TypeCode credentialTypeCode = orb.create_tc_for_type(typeof(CredentialData)); byte[] data = serviceContext.context_data; return((CredentialData)InterceptorsInitializer.Codec.decode_value(data, credentialTypeCode)); }
private void DeactivateConsumer() { if (_subsId != 0) { _theSession.channel.unsubscribe(_subsId); OrbServices.DeactivateObject((MarshalByRefObject)_consumer); _subsId = 0; } }
private void DeactivateObserver() { if (_obsId != 0) { _theSession.unsubscribeObserver(_obsId); OrbServices.DeactivateObject((MarshalByRefObject)_observer); _obsId = 0; } }
public ServerRequestInterceptor GetServerRequestInterceptor(OrbServices orb) { lock (this) { if (m_serverInterceptor == null) { m_serverInterceptor = new BiDirIiopServerInterceptor(orb); } return(m_serverInterceptor); } }
public ClientRequestInterceptor GetClientRequestInterceptor(OrbServices orb) { lock (this) { if (m_clientInterceptor == null) { m_clientInterceptor = new BiDirIiopClientInterceptor(orb); } return(m_clientInterceptor); } }
private void UpdateActivation() { if (_observer != null) { try { DeactivateObserver(); } catch (Exception e) { Logger.Warn("Failed to deactivate previously activated observer: " + e); } try { OrbServices.ActivateObject((MarshalByRefObject)_observer); _obsId = _theSession.subscribeObserver(_observer); Logger.Info("Observer subscribed"); } catch (Exception e) { if (_obsId != 0) { _theSession.unsubscribeObserver(_obsId); } Logger.Error("Error subscribing to the session: " + e); throw; } } if (_consumer != null) { try { DeactivateConsumer(); } catch (Exception e) { Logger.Warn("Failed to deactivate previously activated consumer: " + e); } try { OrbServices.ActivateObject((MarshalByRefObject)_consumer); _subsId = _theSession.channel.subscribe(_consumer); Logger.Info("Consumer registered"); } catch (Exception e) { if (_subsId != 0) { _theSession.channel.unsubscribe(_subsId); } Logger.Error("Error subscribing to the channel: " + e); throw; } } }
public void TestAnyContainer() { System.String testString = "abcd"; OrbServices orb = OrbServices.GetSingleton(); omg.org.CORBA.TypeCode wstringTc = orb.create_wstring_tc(0); Any any = new Any(testString, wstringTc); Any result = m_testService.EchoAny(any); Assertion.AssertEquals(any.Value, result.Value); }
public object RetrieveIdlIntArrayAsAny([IdlArray(0L, 5)] int[] arg) { // test with explicit typecode-creation IOrbServices orbServices = OrbServices.GetSingleton(); omg.org.CORBA.TypeCode arrayTC = orbServices.create_array_tc(5, orbServices.create_tc_for_type(typeof(int))); Any arrayAsAny = new Any(arg, arrayTC); return(arrayAsAny); }
/// <summary> /// Verifica se o objeto CORBA implementa a interface (repository ID). /// </summary> /// <param name="obj">O objeto CORBA.</param> /// <param name="interfaceName">A interface (repository ID).</param> /// <returns></returns> public static bool CheckInterface(MarshalByRefObject obj, string interfaceName) { OrbServices orb = OrbServices.GetSingleton(); try { return(orb.is_a(obj, interfaceName)); } catch (NullReferenceException) { return(false); } }
public OpenBusContextImpl(int connectionIdSlotId, int ignoreThreadSlotId, int joinedChainSlotId, int chainSlotId) { _connections = new ConditionalWeakTable <Object, Connection>(); _connectionIdSlotId = connectionIdSlotId; _ignoreThreadSlotId = ignoreThreadSlotId; _joinedChainSlotId = joinedChainSlotId; _chainSlotId = chainSlotId; _orb = OrbServices.GetSingleton(); _lock = new ReaderWriterLockSlim(); _codec = InterceptorsInitializer.Codec; }
public System.Int32 TestAddToContextData(System.Int32 arg) { ORB orb = OrbServices.GetSingleton(); omg.org.PortableInterceptor.Current current = (omg.org.PortableInterceptor.Current)orb.resolve_initial_references("PICurrent"); int contextData = (int)current.get_slot(m_slotId); int result = contextData + arg; current.set_slot(m_slotId, result); return(result); }
public void SetUp() { m_orb = OrbServices.GetSingleton(); m_profile = new InternetIiopProfile(new GiopVersion(1, 2), "localhost", 1001, new byte[] { 1, 0, 0, 0 }); m_clientChannel = new IiopClientChannel(); ChannelServices.RegisterChannel(m_clientChannel, false); }
public object RetrieveIdlInt3DimArray2x2x3AsAny([IdlArray(0L, 2)][IdlArrayDimension(0L, 1, 2)][IdlArrayDimension(0L, 2, 3)] System.Int32[,,] arg) { // test with explicit typecode-creation IOrbServices orbServices = OrbServices.GetSingleton(); omg.org.CORBA.TypeCode arrayTC = orbServices.create_array_tc(3, orbServices.create_tc_for_type(typeof(int))); arrayTC = orbServices.create_array_tc(2, arrayTC); arrayTC = orbServices.create_array_tc(2, arrayTC); Any arrayAsAny = new Any(arg, arrayTC); return(arrayAsAny); }
/// <summary> /// Resolves a name to a service. /// </summary> /// <param name="name">name to resolve</param> /// <returns>resolved service</returns> /// <exception cref="ServiceException"> /// if a CORBA-related error occurs while resolving the service name /// </exception> public T Resolve(Name name) { try { MarshalByRefObject reference = this.DirContext.resolve(name.Components); // Touch the object to immediately fail if it is unavailable OrbServices.GetSingleton().non_existent(reference); // Jeez, C#... return((T)((object)reference)); } catch (AbstractCORBASystemException e) { throw new ServiceException("Failed to resolve service name " + name, e); } catch (TargetInvocationException e) { throw new ServiceException("Failed to resolve service name " + name, e.InnerException); } }
public void receive_request(ServerRequestInfo ri) { // modify request scope after copy to the thread scope -> must not be propagated to the thread scope. if (ri.operation == "TestReceiveReqNotChangeThreadScope") { ri.set_slot(m_slotId, 2 * (int)ri.get_slot(m_slotId)); } else if (ri.operation == "TestReceiveReqChangeThreadScope") { ORB orb = OrbServices.GetSingleton(); omg.org.PortableInterceptor.Current current = (omg.org.PortableInterceptor.Current)orb.resolve_initial_references("PICurrent"); current.set_slot(m_slotId, 3 * (int)current.get_slot(m_slotId)); } }
public void TestNilReferenceAsAny() { OrbServices orb = OrbServices.GetSingleton(); omg.org.CORBA.TypeCode nilRefTC = orb.create_tc_for_type(typeof(System.MarshalByRefObject)); Any nilRefAny = new Any(null, nilRefTC); object result = m_testService.EchoAny(nilRefAny); Assert.IsNull(result, "result not null"); Any nilRefAny2 = new Any(null, orb.create_interface_tc(String.Empty, String.Empty)); object result2 = m_testService.EchoAny(nilRefAny2); Assert.IsNull(result2, "result not null"); }
public void TestULongAsAny() { int arg = 74; int result = (int)m_testService.RetrieveULongAsAny(arg); Assert.AreEqual(arg, result, "wrong result of retrieveULongAsAny"); OrbServices orb = OrbServices.GetSingleton(); int arg2 = 89; omg.org.CORBA.TypeCode ulongTC = orb.create_ulong_tc(); Any any = new Any(arg2, ulongTC); int result2 = m_testService.ExtractFromULongAny(any); Assert.AreEqual(arg2, result2, "wrong result of ExtractFromULongAny"); }