Excerpts

About This Book Software for networked applications must possess the following qualities to be successful in today's competitive, fast-paced computing industry: Affordability, to ensure that the total ownership costs of software acquisition and evolution are not prohibitively high Extensibility, to support successions of quick updates and additions to address new requirements and take advantage of emerging markets Flexibility, to support a growing range of multimedia data types, traffic patterns, and end-to-end quality of service (QoS) requirements Portability, to reduce the effort required to support applications on heterogeneous OS platforms and compilers Predictability and efficiency, to provide low latency to delay-sensitive real-time applications, high performance to bandwidth-intensive applications, and usability over low-bandwidth networks, such as wireless links Reliability, to ensure that applications are robust, fault tolerant, and highly available Scalability, to enable applications to handle large numbers of clients simultaneously Writing high-quality networked applications that exhibit these qualities is hard--it's expensive, complicated, and error prone. The patterns, C++ language features, and objectoriented design principles presented in C++ Network Programming, Volume 1: Mastering Complexity with ACE and Patterns (C++NPv1) help to minimize complexity and mistakes in networked applications by refactoring common structure and functionality into reusable wrapper facade class libraries. The key benefits of reuse will be lost, however, if large parts of the application software that uses these class libraries--or worse, the class libraries themselves--must be rewritten for each new project. Historically, many networked application software projects began by Designing and implementing demultiplexing and dispatching infrastructure mechanisms that handle timed events and I/O on multiple socket handles Adding service instantiation and processing mechanisms atop the demultiplexing and dispatching layer, along with message buffering and queueing mechanisms Implementing large amounts of application-specific code using this ad hoc host infrastructure middleware This development process has been applied many times in many companies, by manyprojects in parallel. Even worse, it's been applied by the same teams in a series of projects. Regrettably, this continuous rediscovery and reinvention of core concepts and code has kept costs unnecessarily high throughout the software development life cycle. This problem is exacerbated by the inherent diversity of today's hardware, operating systems, compilers, and communication platforms, which keep shifting the foundations of networked application software development. Object-oriented frameworks are one of the most flexible and powerful techniques that address the problems outlined above. A framework is a reusable, "semi-complete" application that can be specialized to produce custom applications. Frameworks help to reduce the cost and improve the quality of networked applications by reifying proven software designs and patterns into concrete source code. By emphasizing the integration and collaboration of application-specific and application-independent classes, frameworks enable larger scale reuse of software than can be achieved by reusing individual classes or stand-alone functions. In the early 1990s, Doug Schmidt started the open-source ACE project to bring the power and efficiency of patterns and frameworks to networked application development. As with much of Doug's work, ACE addressed many real-world problems faced by professional software developers. Over the following decade, his groups at the University of California, Irvine; Washington University, St. Louis; and Vanderbilt University, along with contributions from the ACE user community and Steve Huston at Riverace, yielded a C++ toolkit containing some of the most powerful and widely used concurrent object-oriented network programming frameworks in the world. By applying reusable software patterns and a lightweight OS portability layer, the frameworks in the ACE toolkit provide synchronous and asynchronous event processing; concurrency and synchronization; connection management; and service configuration, initialization, and hierarchical integration. The success of ACE has fundamentally altered the way that networked applications and middleware are designed and implemented on the many operating systems outlined in Sidebar 2 (page 16 in the book). ACE is being used by thousands of development teams, ranging from large Fortune 500 companies to small startups to advanced research projects at universities and industry labs. Its open-source development model and self-supporting culture is similar in spirit and enthusiasm to that driving Linus Torvalds's popular Linux operating system. This book describes how the ACE frameworks are designed and how they can help developers navigate between the limitations of Low-level native operating system APIs, which are inflexible and nonportable High-level middleware, such as distribution middleware and common middleware services, which often lacks the efficiency and flexibility to support networked applications with stringent QoS and portability requirements The skills required to produce and use networked application frameworks have traditionally been locked in the heads of expert developers or buried deep within the source code of numerous projects that are spread throughout an enterprise or an industry. Neither of these locations is ideal, of course, since it's time consuming and error prone to reengineer this knowledge for each new application or project. To address this problem, this book illustrates the key patterns that underlie the structure and functionality of the ACE frameworks. Our coverage of these patterns also makes it easier to understand the design, implementation, and effective use of the open-source ACE toolkit itself. Intended Audience This book is intended for "hands on" C++ developers or advanced students interested in understanding how to design object-oriented frameworks and apply them to develop networked applications. It builds upon material from C++NPv1 that shows how developers can apply patterns to master complexities arising from using native OS APIs to program networked applications. It's therefore important to have a solid grasp of the following topics covered in C++NPv1 before reading this book: Networked application design dimensions, including the alternative communication protocols and data transfer mechanisms discussed in Chapter 1 of C++NPv1 Internet programming mechanisms, such as TCP/IP connection management and data transfer APIs discussed in Chapter 2 of C++NPv1 Concurrency design dimensions, including the use of processes and threads, iterative versus concurrent versus reactive servers, and threading models discussed in Chapters 5 through 9 of C++NPv1 Synchronization techniques necessary to coordinate the interactions of processes and threads on various OS platforms discussed in Chapter 10 of C++NPv1 Object-oriented design and programming techniques that can simplify OS APIs and avoid programming mistakes through the use of patterns, such as Wrapper Facade and Proxy discussed in Chapter 3 and Appendix A of C++NPv1 The ACE frameworks are highly flexible and powerful, due in large part to their use of C++ language features. You should therefore be familiar with C++ class inheritance and virtual functions (dynamic binding) as well as templates (parameterized types) and the mechanisms your compiler(s) offer to instantiate them. ACE provides a great deal of assistance in overcoming differences between C++ compilers. As always, however, you need to know the capabilities of your development tools and how to use them. Knowing your tools makes it easier to follow the source code examples in this book and to build and run them on your systems. Finally, as you read the examples in this book, keep in mind the points noted in Sidebar 7 (page 46 in the book) regarding UML diagrams and C++ code. Structure and Content Our C++NPv1 book addressed how to master certain complexities of developing networked applications, focusing on the use of ACE's wrapper facades to avoid problems with operating system APIs written in C. This book (which we call C++NPv2) elevates our focus to motivate and demystify the patterns, design techniques, and C++ features associated with developing and using the ACE frameworks. These frameworks help reduce the cost and improve the quality of networked applications by reifying proven software designs and patterns into frameworks that can be reused systematically across projects and enterprises. The ACE frameworks expand reuse technology far beyond what can be achieved by reusing individual classes or even class libraries. This book presents numerous C++ applications to reinforce the design discussions by showing concrete examples of how to use the ACE frameworks. These examples provide step-by-step guidance that can help you apply key object-oriented techniques and patterns to your own networked applications. The book also shows how to enhance your design skills, focusing on the key concepts and principles that shape the design of successful objectoriented frameworks for networked applications and middleware. The chapters in the book are organized as follows: Chapter 1 introduces the concept of an object-oriented framework and shows how frameworks differ from other reuse techniques, such as class libraries, components, patterns, and model-integrated computing. We then outline the frameworks in the ACE toolkit that are covered in subsequent chapters. Chapter 2 completes the domain analysis begun in C++NPv1, which covered the communication protocols and mechanisms, and the concurrency architectures used by networked applications. The focus in this book is on the service and configuration design dimensions that address key networked application properties, such as duration and structure, how networked services are identified, and the time at which they are bound together to form complete applications. Chapter 3 describes the design and use of the ACE Reactor framework, which implements the Reactor pattern to allow event-driven applications to demultiplex and dispatch service requests that are delivered to an application from one or more clients. Chapter 4 then describes the design and use of the most common implementations of theACE_Reactorinterface, which support a wide range of OS event demultiplexing mechanisms, includingselect(), WaitForMultipleObjects(), XtAppMainLoop(),and/dev/poll. Chapter 5 describes the design and use of the ACE Service Configurator framework. This framework implements the Component Configurator pattern to allow an application to link/unlink its component service implementations at run time without having to modify, recompile, or relink the application statically. Chapter 6 describes the design and effective use of the ACE Task framework. This framework can be used to implement key concurrency patterns, such as Active Object and Half-Sync/Half-Async. Chapter 7 describes the design and effective use of the ACE Acceptor-Connector framework. This framework implements the Acceptor-Connector pattern to decouple the connection and initialization of cooperating peer services in a networked system from the processing they perform once connected and initialized. Chapter 8 describes the design and use of the ACE Proactor framework. This framework implements the Proactor and Acceptor-Connector patterns to allow event-driven applications to efficiently demultiplex and dispatch service requests triggered by the completion of asynchronously initiated operations. Chapter 9 describes the design and use of the ACE Streams framework. This framework implements the Pipes and Filters pattern to provide a structure for systems that process streams of data. The book concludes with a glossary of technical terms, a list of references for further study, and a general subject index. The chapters are organized to build upon each other and to minimize forward references. We therefore recommend that you read the chapters in order. Although this book illustrates the key capabilities of ACE's most important frameworks, we don't cover all uses and methods of those frameworks. For additional coverage of ACE, we refer you to The ACE Programmer's Guide and the online ACE reference documentation, generated by Doxygen Dim01. ACE's reference documentation is available at http://ace.ece.uci.edu/Doxygen/ and http://www.riverace.com/docs/. Related Material This book is based on ACE version 5.3, released in the fall of 2002. ACE 5.3 and all the sample applications described in our books are open-source software. Sidebar 3 (page 19 in the book) explains how you can obtain a copy of ACE so you can follow along, see the actual ACE classes and frameworks in complete detail, and run the code examples interactively as you read the book. To learn more about ACE, or to report errors you find in the book, we recommend you subscribe to the ACE mailing list, ace-users@cs.wustl.edu. You can subscribe by sending a request to ace-users-request@cs.wustl.edu. Include the following command in the body of the e-mail (the subject is ignored): subscribe ace-users emailaddress@domain You must supplyemailaddress@domainonly if your message'sFromaddress is not the address you wish to subscribe. If you use this alternate address method, the list server will require an extra authorization step before allowing you to join the list. Postings to theace-userslist are also forwarded to thecomp.soft-sys.aceUSENET newsgroup, along with postings to several other ACE-related mailing lists. Reading the messages via the newsgroup is a good way to keep up with ACE news and activity if you don't require immediate delivery of the 30 to 50 messages that are posted daily on the mailing lists. Archives of postings to the comp.soft-sys.ace newsgroup are available at http: //groups.google.com/. Entercomp.soft-sys.acein the search box to go to a list of archived messages. Google has a complete, searchable archive of over 40,000 messages. You can also post a message to the newsgroup from Google's site. 0201795256P11042002 Excerpted from C++ Network Programming: Systematic Reuse with ACE and Frameworks by Douglas C. Schmidt, Stephen D. Huston All rights reserved by the original copyright owners. Excerpts are provided for display purposes only and may not be reproduced, reprinted or distributed without the written permission of the publisher.