A Quick CCM Example

1. A Quick CCM Example

2. Introduction A Simple Sender&Receiver Scenario • Sender sends out the click-out event to inform the Receiver. • Receiver reads the message from Sender. • Multiple instances of the Receiver could be deployed. • $CIAO_ROOT/examples/Hello • $CIAO_ROOT/examples/Hello/step-by-step.html

3. Steps To Develop A CIAO Based Application • Define your IDL types. • Define your Component types. • Implement your components. • Assemble your components. • Deploy and run your application.

4. A Quick CCM Example Define IDL/Component Types

5. Common IDL module Hello { interface message { string get_message(); }; eventtype timeout{ }; }; • Common IDL definition. • Used by both Sender and Receiver. • $CIAO_ROO/examples/Hello/Hello_Base/Hello_Base.idl • This file could be skipped if not necessary.

6. Component Definition (IDL) – Receiver 1/3 • Define the event receptacle. //Receiver.idl component Receiver{ uses message read_message; consumes timeout click_in; }; home ReceiverHome managesReceiver{};

7. Component Definition (IDL) – Receiver 2/3 • Define the interface receptacle. //Receiver.idl component Receiver{ uses message read_message; consumes timeout click_in; }; home ReceiverHome managesReceiver{};

8. Component Definition (IDL) – Receiver 3/3 //Receiver.idl component Receiver{ uses message read_message; consumes timeout click_in; }; home ReceiverHome managesReceiver{}; • Define the component home

9. Component Definition (IDL) – Sender 1/5 • Define the event source. //Sender.idl interface trigger {void start ();}; component Sender supports trigger {provides message push_message; publishes timeout click_out; attribute string local_message;}; home SenderHome manages Sender{};

10. Component Definition (IDL) – Sender 2/5 • Define the interface facet. • The interface facet is plugged into the component in the way of composition. //Sender.idl interface trigger {void start ();}; component Sender supports trigger {provides message push_message; publishes timeout click_out; attribute string local_message;}; home SenderHome manages Sender{};

11. Component Definition (IDL) – Sender 3/5 • Define the attribute. //Sender.idl interface trigger {void start ();}; component Sender supports trigger {provides message push_message; publishes timeout click_out; attribute string local_message;}; home SenderHome manages Sender{};

12. Component Definition (IDL) – Sender 4/5 • Sender specific interface. //Sender.idl interface trigger {void start ();}; component Sender supports trigger {provides message push_message; publishes timeout click_out; attribute string local_message;}; home SenderHome manages Sender{}; • Supported interface which is part of the component (inheritance).

13. Component Definition (IDL) – Sender 5/5 • Define the component home. //Sender.idl interface trigger {void start ();}; component Sender supports trigger {provides message push_message; publishes timeout click_out; attribute string local_message;}; home SenderHome manages Sender{};

14. A Quick CCM Example Component Implementations

15. What does CIDL do? 1/2 CIDL is part of CCM strategy for managing complex applications • Helps separation of concerns • Helps coordination of tools • Increases the ratio of generated to hand-written code • Server code is now generated, startup automated by other CCM tools uses

16. What does CIDL do? 2/2 • A CIDL file is Passed to CIDL compiler • Triggers code generation for • Component Home(SenderHome) • managed component (Senderer) • CIDL compiler generates • SenderHome servant • Senderer servant • attribute operations • port operations • supported interface operations • container callback operations • navigation operation overrides • IDL executor mapping • XML descriptor with meta-data

17. Sender.cidl // Sender.cidl composition session Sender_Impl { home executor SenderHome_Exec {implements SenderHome; manages Sender_Exec;} }; • An executor is where a component/home is implemented • The component/home’s servant will forward a client’s business logic request on the component to its corresponding executor • User should write the implementations (specified in the exacutor mapping IDL file) of: • SenderHome_Exec • Sender_Exec Which are (In the example): • class SenderHome_exec_i • class Sender_exec_i SenderHome servant SenderHome_Exec Manages Sender servant Sender_Exec

18. Executor Mapping 1/2 CIDL compiler generates the Executor Mapping • An IDL file consists of local interface definitions. • IDL compiler will generate the stubs for these local interfaces. Home servant uses Home_Exec Manages Defines Component servant Component_Exec

19. Executor Mapping 2/2 //Sender.cidl –snipped-- composition session Sender_Impl { home executor SenderHome_Exec { implements Hello::SenderHome; manages Sender_Exec; };}; //SenderE.idl --snipped— Module Sender_Impl { local interface Sender_Exec: … Local interface SenderHome_Exec: … }; CIDL Compiler IDL Compiler User writes Auto-generated //Sender_exec.h --snipped— namespace Sender_Impl { class Sender_Exec_i: public virtual Sender_Exec … class SenderHome_Exec_i: public virtual SenderHome_Exec … }; //SenderEC.h --snipped— namespace Sender_Impl { class Sender_Exec: … class SenderHome_Exec: … }; Inheritance

20. A Quick CCM Example Implementation in Detail

21. Implementation in Detail - Overview • Component Specific context • Interface connection • Facet • Receptacle • Event connection • Event source • Event receptacle • Attribute • Component Entry point Handles all connections/subscriptions

22. Initializing Component-specific Context • Component-specific context manages connections & subscriptions • Container passes component its context via either • set_session_context() • set_entity_context() class Sender_exec_i : public virtual Sender_Exec, public virtual CORBA::LocalObject{protected:Sender_Exec_Context_var context_;public: … void set_session_context (Components::SessionContext_ptr c) { this->context_ =Sender_Exec_Context::narrow (c); } …}; //SenderE.idl –snipped-- local interface Sender_Exec :Hello::CCM_Sender,Components::SessionComponent{};

23. Implement the Provided Interface Facet 1/2 //Hello_Base.idl –snipped-- Module Hello { interface message { …}; … } //Sender_exec.h --snipped— namespace Sender_Impl { class Sender_Exec_i: public virtual Sender_Exec … { public : … get_push_message () {return (new Message_Impl(…)); } }; class Message_Impl : public virtual CCM_message … { //All operations in interface //message }; }; //Sender.idl –snipped-- component Sender supports trigger {provides message push_message; …}; //SenderE.idl --snipped— Module Hello{ local interface CCM_message:message … local interface CCM_Sender : … { Hello::CCM_message get_push_message(); } }; We use Message_Impl to implement interface message. In this example, we intend to plug the facet into the component. In C++ terminology, we use composition but not inheritance.

24. Implement the Provided Interface Facet 2/2 //Hello_Base.idl –snipped-- Module Hello { interface message { …}; … } //Sender_exec.h --snipped— namespace Sender_Impl { class Sender_Exec_i: public virtual Sender_Exec … { public : … get_push_message () {return (new Message_Impl(…)); } }; class Message_Impl : public virtual CCM_message … { //All operations in interface //message }; }; //Sender.idl –snipped-- component Sender supports trigger {provides message push_message; …}; //SenderE.idl --snipped— Module Hello{ local interface CCM_message:message … local interface CCM_Sender : … { Hello::CCM_message get_push_message(); } }; We plug the interface facet into the component and implement the get_<facet-name> method, which will be called by D&C tools or client to get the object reference of the interface servant implementation. User is responsible for managing the lifecycle of the facet object.

25. Invocation on Interface Receptacle //Hello_Base.idl –snipped-- Module Hello { interface message { String get_message (); }; … }; //Receiver_exec.h/cpp --snipped— namespace Receiver_Impl { class Receiver_Exec_i: public virtual Receiver_Exec … { public : void push_click_in () { Hello::message_var rev = this->context_->get_connection_read_message(); CORBA::String_var str = rev->get_message(); } };}; //Receiver.idl –snipped-- component Receiver { uses message read_message; … }; Get the Obj-Ref Operation invocation • Component specific context manages the receptacle connections. • Component executor implementation acquires the connected reference by calling: • get_connection_<receptacle-name>. Then you can invoke opertaions supported by the interface on the OBJ reference.

26. Send out an Event //Hello_Base.idl –snipped-- Module Hello { eventtype timeout { …}; … } //Sender_exec.h/cpp --snipped— namespace Sender_Impl { class Sender_Exec_i: public virtual Sender_Exec … { public : void start () { this->context_-> push_click_out(); } };}; //Sender.idl –snipped-- Component Sender.idl {publishes timeoutclick_out; … }; //SenderE.idl --snipped— module Hello{ local interface CCM_Sender_Contex : …{ void push_click_out(); } }; module Sender_Impl { typedef Hello::CCM_Sender_Contex Sender_Exec_Contex; }; • Component specific context manages the event source. • push_<eventsource-name> sends out a event.

27. Upon Receiving an Event //Hello_Base.idl –snipped-- Module Hello { eventtype timeout {}; … }; //Receiver_exec.h --snipped— namespace Receiver_Impl { class Receiver_Exec_i: public virtual Receiver_Exec … { public : void push_click_in (); }; }; //Receiver.idl –snipped-- component Receiver { consuems timeout click_in; … }; //ReceiverE.idl --snipped— module Hello{ local interface CCM_Receiver : …{ void push_click_in(); } }; module Sender_Impl { Hello::CCM_Receiver_Exec : CCM_Receiver {}; }; • CIDL generates event consumer servants • Executor mapping defines push operations directly • push_<eventsink-name> will be called upon receiving an event.

28. Attribute Implementation //Sender.idl –snipped-- component Sender { attribute string local_message; … }; //Sender_exec.h --snipped— namespace Sender_Impl { class Sender_Exec_i: public virtual Sender_Exec … { public : voidlocal_message(const char* ); char *local_message(); }; }; //SenderE.idl --snipped— module Hello{ local interface CCM_Sender : …{ attribute string local_message; } }; module Sender_Impl { Hello::CCM_Receiver_Exec : CCM_Receiver {}; }; • Intended for component configuration • User need to implement the Accessor and Mutator methods.

29. Component Entry Point Assembly extern "C" { Components::HomeExecutorBase_ptrcreatSenderHome_Impl (void) { return new Sender_Impl::SenderHome_exec_i();} } ServerActivator «instantiates» ComponentServer «instantiates» Container • The signature is defined by the CCM spec • Container calls this method to create a home executor • extern “C” required to prevent C++ name mangling, so function name can be resolved in DLL • XML tag reserved for entry point name «instantiates» CCMHome ... createSenderHome_Impl ()