WIXLIB

Advanced ACE TutorialDouglas C. SchmidtNetworked Logging Service Programming APIThe logging API is similar to printf(), e.g.:ACE ERROR ((LM ERROR, "(%t) fork failed"));Generates on logging server host:Oct 31 14:50:13 1992@tango.ics.uci.edu@2766@LM ERROR@client::(4) fork failedandACE DEBUG ((LM DEBUG,"(%t) sending to server %s", server host));generates on logging server host:Oct 31 14:50:28 1992@zola.ics.uci.edu@18352@LM DEBUG@drwho::(6) sending to server bastilleVanderbilt University25

Advanced ACE TutorialDouglas C. SchmidtConventional Logging Server DesignTypical algorithmic pseudo-code forThe “grand mistake:”networked logging server: Avoid the temptation tovoid logging server (void) {“step-wise refine” thisinitialize acceptor endpointalgorithmicallydecomposedloop forever {pseudo-code directly intowait for eventsthe detailed design andhandle data eventsimplementation of thehandle connection eventslogging server!}}Vanderbilt University26

Advanced ACE TutorialDoThe select()-based Logging NG DAEMONmaxhandlep1acceptorread GRECORDSCLIENTLOGGINGRECORDSCLIENTSerializes server processing at select()demuxing levelVanderbilt University

Advanced ACE TutorialConventional Logging ServerImplementationNote the excessive amount of detail required toprogram at the socket level.// Main programstatic const int PORT 10000;typedef u long COUNTER;typedef int HANDLE;// Counts the # of logging records processedstatic COUNTER request count;// Acceptor-mode socket handlestatic HANDLE acceptor;// Highest active handle number, plus 1static HANDLE maxhp1;// Set of currently active handlesstatic fd set activity handles;// Scratch copy of activity handlesstatic fd set ready handles;Vanderbilt UniversityDo

Advanced ACE TutorialMain Event Loop of Logging Serverint main (int argc, char *argv[]){initialize acceptor(argc 1 ? atoi (argv[1]) : PORT);// Loop forever performing logging// server processing.for (;;) {// struct assignment.ready handles activity handles;// Wait for client I/O events.select (maxhp1, &ready handles, 0, 0, 0);// First receive pending logging records.handle data ();// Then accept pending connections.handle connections ();}}Vanderbilt UniversityDo

Advanced ACE TutorialInitialize Acceptor Socketstatic void initialize acceptor (u short port){struct sockaddr in saddr;// Create a local endpoint of communication.acceptor socket (PF INET, SOCK STREAM, 0);// Set up the address info. to become server.memset ((void *) &saddr, 0, sizeof saddr);saddr.sin family AF INET;saddr.sin port htons (port);saddr.sin addr.s addr htonl (INADDR ANY);// Associate address with endpointbind (acceptor,(struct sockaddr *) &saddr,sizeof saddr);// Make endpoint listen for connection requests.listen (acceptor, 5);// Initialize handle sets.FD ZERO (&ready handles);FD ZERO (&activity handles);FD SET (acceptor, &activity handles);maxhp1 acceptor 1;}Vanderbilt UniversityDo

Advanced ACE TutorialHandle Data Processingstatic void handle data (void) {// acceptor 1 is the lowest client handlefor (HANDLE h acceptor 1; h maxhp1; h )if (FD ISSET (h, &ready handles)) {ssize t n handle log record (h, 1);// Guaranteed not to block in this case!if (n 0) request count;// Count the # of logging recordselse if (n 0) {// Handle connection shutdown.FD CLR (h, &activity handles);close (h);if (h 1 maxhp1) {// Skip past unused handleswhile (!FD ISSET (--h,&activity handles))continue;maxhp1 h 1;}}}}Vanderbilt UniversityDo

Advanced ACE TutorialDoReceive and Process Logging Recordsstatic ssize t handle log record (HANDLE in h,HANDLE out h) {ssize t n;size t len;Log Record lr;// The first recv reads the length (stored as a// fixed-size integer) of adjacent logging record.n recv (in h, (char *) &len, sizeof len, 0);if (n 0) return n;len ntohl (len); // Convert byte-ordering// The second recv then reads len bytes to// obtain the actual record.for (size t nread 0; nread len; nread nn recv (in h, ((char *) &lr) nread,len - nread, 0);// Decode and print record.decode log record (&lr);if (write (out h, lr.buf, lr.size) -1)return -1;else return 0;}Vanderbilt University

Advanced ACE TutorialHandle Connection Acceptancestatic void handle connections (void){if (FD ISSET (acceptor, &ready handles)) {static struct timeval poll tv {0, 0};HANDLE h;// Handle all pending connection requests// (note use of select’s polling feature)do {// Beware of subtle bug(s) here.h accept (acceptor, 0, 0);FD SET (h, &activity handles);// Grow max. socket handle if necessary.if (h maxhp1)maxhp1 h 1;} while (select (acceptor 1, &ready handles,0, 0, &poll tv) 1);}Vanderbilt UniversityDo

Advanced ACE TutorialConventional Client LoggingDaemon ImplementationThe main() method receives logging records fromclient applications and forwards them on to thelogging serverint main (int argc, char *argv[]){HANDLE stream initialize stream endpoint(argc 1? atoi (argv[1]): PORT);Log Record lr;// Loop forever performing client// logging daemon processing.for (;;) {// . get logging records from client//application processes .size t size htonl (lr.size);send (stream, &size, sizeof size);encode log record (&lr);send (stream, ((char *) &lr), sizeof lr);}}Vanderbilt UniversityDo

Advanced ACE TutorialDoClient Connection Establishmentstatic HANDLE initialize stream endpoint(const char *host, u short port){struct sockaddr in saddr;// Create a local endpoint of communication.HANDLE stream socket (PF INET, SOCK STREAM, 0);// Set up the address info. to become client.memset ((void *) &saddr, 0, sizeof saddr);saddr.sin family AF INET;saddr.sin port htons (port);hostent *hp gethostbyname (host);memcpy ((void *) &saddr,htonl (hp- h addr),hp- h length);// Associate address with endpointconnect (stream,(struct sockaddr *) &saddr,sizeof saddr);return stream;}Vanderbilt University

Advanced ACE TutorialDouglas C. SchmidtLimitations with Algorithmic DecompositionAlgorithmic decomposition tightly couples application-specificfunctionality and the following configuration-related characteristics: Application Structure– The number of services per process– Time when services are configured into a process Communication and Demultiplexing Mechanisms– The underlying IPC mechanisms that communicate with otherparticipating clients and servers– Event demultiplexing and event handler dispatching mechanisms Concurrency and Synchronization Model– The process and/or thread architecture that executes service(s) atrun-timeVanderbilt University36

Advanced ACE TutorialDouglas C. SchmidtOvercoming Limitations via OO The algorithmic decomposition illustrated above specifies manylow-level details– Moreover, the excessive coupling impedes reusability,extensibility, and portability. In contrast, OO focuses on application-specific behavior, e.g.,int Logging Handler::handle input (void){ssize t n handle log record (peer ().get handle (),ACE STDOUT);if (n 0) request count; // Count the # of logging recordsreturn n 0 ? -1 : 0;}Vanderbilt University37

Advanced ACE TutorialDouglas C. SchmidtOO Contributions to Software Patterns facilitate the large-scale reuse of software architecture– Even when reuse of algorithms, detailed designs, andimplementations is not feasible Frameworks achieve large-scale design and code reuse– In contrast, traditional techniques focus on the functions andalgorithms that solve particular requirements Note that patterns and frameworks are not unique to OO!– However, objects and classes are useful abstraction mechanismsVanderbilt University38

Advanced ACE TutorialDouglas C. SchmidtPatterns in the Networked Logging ctorSTRATEGICPATTERNSTACTICAL WrapperFacade Strategic and tactical are relative to the context and abstraction levelVanderbilt University39

Advanced ACE TutorialDouglas C. SchmidtSummary of Pattern Intents Wrapper Facade ! “Encapsulates the functions and data providedby existing non-OO APIs within more concise, robust, portable,maintainable, and cohesive OO class interfaces” Reactor ! “Demultiplexes and dispatches requests that aredelivered concurrently to an application by one or more clients” Acceptor ! “Decouple the passive connection and initialization of apeer service in a distributed system from the processing performedonce the peer service is connected and initialized” Component Configurator ! “Decouples the implementation ofservices from the time when they are configured” Active Object ! “Decouples method execution from methodinvocation to enhance concurrency and simplify synchronizedaccess to an object that resides in its own thread of control”Vanderbilt University40

Advanced ACE TutorialDouglas C. SchmidtComponents in the OO Logging Server Application-specific components– Process logging records received from clients Connection-oriented application components– ACE Svc Handler (service handler) Performs I/O-related tasks with clients– ACE Acceptor factory Passively accepts connection requests Dynamically creates a service handler for each client and“activates” it Application-independent ACE framework components– Perform IPC, explicit dynamic linking, event demultiplexing, eventhandler dispatching, multi-threading, etc.Vanderbilt University41

Advanced ACE PECIFICCOMPONENTSClass Diagram for OO Logging ServerLogging HandlerSOCK Acceptor1LoggingAcceptorSOCK StreamNull Synchn activates LoggingHandlerSVC HANDLERPEER ERACCEPTORPEERSTREAMConnectionStreamIPC SAPServiceConfiguratorConcurrencyVanderbilt UniversityPEER STREAMSYNCH STRATReactor

Advanced ACE TutorialDouglas C. SchmidtAddressing Robustness, Portability,and Maintainability Challenges Problem– Building distributed applications using low-level APIs is hard Forces– Low-level APIs are verbose, tedious, and error-prone to program– Low-level APIs are non-portable and non-maintainable Solution– Apply the Wrapper Facade pattern to encapsulate low-levelfunctions and data structuresVanderbilt University43

Advanced ACE TutorialDouglas C. SchmidtThe Wrapper Facade PatternIntent Encapsulates the functionsand data provided byexisting lower-level,non-OO APIs within moreconcise, robust, portable,maintainable, and cohesivehigher-level OO classinterfacesclient1: method k()WrapperFacademethod 1().method m()2: function k()Functionsfunction 1().function n()POSA2 (www.cs.wustl.edu/ schmidt/POSA/)Forces Resolved Avoid tedious, error-prone, and non-portable system APIs Create cohesive abstractionsVanderbilt University44

Advanced ACE TutorialDoMotivating the Wrapper Facade Pattern:the Socket API2: ACTIVE1: nd()/recv()close()CLIENT3: pt()send()/recv()close()SERVERSockets are the most common networkprogramming API and are available on most OSplatformsVanderbilt University

Advanced ACE TutorialDouglas C. SchmidtProblem with Sockets: Lack of Type-safetyint buggy echo server (u short port num) I/O handles are{ // Error checking omitted.not amenable tosockaddr in s addr;strong typeint acceptor checking atsocket (PF UNIX, SOCK DGRAM, 0);compile-times addr.sin family AF INET;s addr.sin port port num; The adjacents addr.sin addr.s addr INADDR ANY;bind (acceptor, (sockaddr *) &s addr,code containssizeof s addr);many subtle,int handle accept (acceptor, 0, 0);common bugsfor (;;) {char buf[BUFSIZ];ssize t n read (acceptor, buf, sizeof buf);if (n 0) break;write (handle, buf, n);}}Vanderbilt University46

Advanced ACE TutorialDouglas C. SchmidtProblem with Sockets: Steep Learning CurveMany socket/TLI API functions have complex semantics, e.g.: Multiple protocol families and address families– e.g., TCP, UNIX domain, OSI, XNS, etc. Infrequently used features, e.g.:––––Broadcasting/multicastingPassing open file handlesUrgent data delivery and receptionAsynch I/O, non-blocking I/O, I/O-based and timer-based eventmultiplexingVanderbilt University47

Advanced ACE TutorialDouglas C. SchmidtProblem with Sockets: Portability Having multiple “standards,” i.e., sockets and TLI, makes portabilitydifficult, e.g.,– May require conditional compilation– In addition, related functions are not included in POSIX standards e.g., select(), WaitForMultipleObjects(), and poll() Portability between UNIX and Windows Sockets is problematic, e.g.:–––––Header filesError numbersHandle vs. descriptor typesShutdown semanticsI/O controls and socket optionsVanderbilt University48

Advanced ACE Tutorial49Douglas C. SchmidtProblem with Sockets: Poorly StructuredVanderbilt University Non-portable There is no consistency among names. Socket API is linear rather than e()getservbyname()

Advanced ACE TutorialDoDATAGRAMN/IO ONTCTINE ICAIVENSNSCO MU LEPAMORERCOXFETIVCASTREAM CONNECTEDDATAGRAMTYPE OF COMMUNICATION SERVICESocket TaxonomyCOMMUNICATION DOMAINLOCAL/REMOTELOCALsocket(PF UNIX)/bind()sendto()/recvfrom()socket(PF UNIX)/bind()socket(PF INET)/bind()sendto()/recvfrom()socket(PF INET)/bind()socket(PF UNIX)socket(PF send()/recv()socket(PF UNIX)socket(PF INET)bind()/connect()bind()/connect()socket(PF F UNIX)bind()/connect()socket(PF F INET)bind()/connect()The Socket API can be classified along threedimensions1. Connection role2. Communication domain3. Type of serviceVanderbilt University

Advanced ACE TutorialDoN/ NOICT ATIOENICIVENSNCO MU AGRAMSTREAMTYPE OF COMMUNICATION SERVICESolution: ACE Socket Wrapper FacadesCOMMUNICATION DOMAINLOCAL/REMOTELOCALramgDKCSOSOCK Dgram BcastSOCK Dgram McastSOCK DgramLSOCK DgramLSOCK CODgramSOCK CODgramLSOCK AcceptorLSOCK StreamLSOCK ConnectorSOCK AcceptorSOCK StreamSOCK ConnectorThe ACE C wrapper facades more explicitlymodel the key socket components using OOclassesVanderbilt University

Advanced ACE TutorialDoThe ACE Connection-OrientedSocket Wrapper FacadesACE IPC SAPACE SOCK IOACE SOCKACE SOCK AcceptorACE SOCK StreamACE AddrACE INET AddrACE SOCK ConnectorParticipants Passive and active connection factories– ACE SOCK Acceptor and ACE SOCK ConnectorStreaming classes– ACE SOCK Stream and ACE SOCK IOAddressing classes– ACE Addr and ACE INET AddrVanderbilt University

Advanced ACE TutorialDouglas C. SchmidtThe ACE Connection-Oriented SocketWrapper Facade Factoriesclass ACE SOCK Connector{public:// Traitstypedef ACE INET Addr PEER ADDR;typedef ACE SOCK Stream PEER STREAM;int connect(ACE SOCK Stream &new sap,const ACE INET Addr &raddr,ACE Time Value *timeout,const ACE INET Addr &laddr);// .};Vanderbilt Universityclass ACE SOCK Acceptor: public ACE SOCK{public:// Traitstypedef ACE INET Addr PEER ADDR;typedef ACE SOCK Stream PEER STREAM;ACE SOCK Acceptor (const ACE INET Addr &);int open (const ACE INET Addr &addr);int accept(ACE SOCK Stream &new sap,ACE INET Addr *,ACE Time Value *);//.};53

Advanced ACE TutorialDouglas C. SchmidtACE Connection-Oriented Socket Wrapper FacadeStreaming and Addressing Classesclass ACE SOCK Stream: public ACE SOCK {public:// Trait.typedef ACE INET Addr PEER ADDR;ssize t send (const void *buf,int n);ssize t recv (void *buf,int n);ssize t send n (const void *buf,int n);ssize t sendv n (const iovec *iov,int n);ssize t recv n (void *buf, int n);int close (void);// .};Vanderbilt Universityclass ACE INET Addr: public ACE Addr{public:ACE INET Addr (u short port,const char host[]);u short get port number (void);ACE UINT 32 get ip addr (void);// .};54

Advanced ACE TutorialDouglas C. SchmidtDesign Interlude: Motivating theSocket Wrapper Facade Structure Q: Why decouple the ACE SOCK Acceptor and theACE SOCK Connector from ACE SOCK Stream? A: For the same reasons that ACE Acceptor andACE Connector are decoupled from ACE Svc Handler, e.g.,– An ACE SOCK Stream is only responsible for data tra

RTOS platforms, running on TCP/IP networks using C Examples are illustrated using freely available ADAPTIVE Communication Environment (ACE) OO framework components – Although ACE is written in C , the principles covered in this tutorial apply to