Upload
elisabeth-ferguson
View
216
Download
0
Tags:
Embed Size (px)
Citation preview
Pattern Oriented SoftwareArchitecture
for Networked Objects
Based on the book
By
Douglas Schmidt
Michael Stal
Hans Roehnert
Frank Buschmann
Scope of application of patternsfor Networking and Distributed Systems
• Applications to “middleware” development.• Applications to higher and lower-level systems and
applications not based directly on middleware.• As hardware capacity and sophistication increases, software
needs to keep up.• Decrease complexity of the process of software development
for complex networks and services.• Continuous reinvention of core concepts leads to changes in
the underlying software components.
• Object – oriented approach leads to the modular approach
and faster development.
Four important aspects of Networked Application Development
Service Access and Configuration
-Effectively design and configure application access to the system interface and implementation of evolving service components.
Wrapper Façade Pattern – This design pattern shields the developer from having to interface with the low level system specific functions.
Component Configurator Pattern – This allows the for the dynamic initialization and stopping of services/components.
Interceptor Pattern – Allows for the handling of unexpected events into the software framework so that responses to these events can be handled at run – time.
Extension Interface – This allows for the addition of extra interfaces
into the applications without affecting applications itself.
Wrapper Façade Pattern
Server
Client
1.socket();6)thre_cre();2.bind();3.listen();5.accept();
8.recv();9.write();
Handle FactoryLoggingHandler
4)connect();send();
Prototype for short throw-away types of applications
ClassWrapper Facade
ResponsibiltyEncapsulates non-object functions And data structures with a cohesive object-oriented abstraction
Collaborator-API Functions
CRC card for Wrapper Façade Class
Application using Wrapper Façade sequence diagram
Known Uses of Wrapper Façade
• ACE – This is a set of C++ classes which allow the user to use/extend low-level system API’s.
• JVM and class libraries – These use the low – level system API’s .The JVM itself is a Wrapper Façade.
• A simple book organization system – Individual papers and books are organized into various “themes” so that the collection can be easily accessible.
Event Handling-It is important to have efficient event-driven applications. Two patterns which help achieve this are :
Reactor pattern :- Allows event-driven applications to demultiplex and dispatch service requests from clients.
Acceptor – Connector Design pattern:- Decouples the connection and initialization of co-operating services from
the processing done by the services after they are connected
and initialized.
Acceptor – Connector Pattern
Problem-How to separate initialization and connection establishment from service behavior.
Solution-An Acceptor waits for connection requests and dispatches them to a reactor.-A Connector initiates connection with servers and dispatches replies to a Reactor.
- Acceptor and Connector decouple passive and active roles during service initialization.
CRC cards for Acceptor – Connector pattern
Class Acceptor
Responsibility-Passively connects and initializes an associated service Handler.
Collaborator -Service handler.-Dispatcher- Transport Endpoint
Class Connector Collaborator
-Service handler.-Dispatcher- Transport Endpoint
Responsibility-Actively connects and initializes an associated service Handler.
Responsibility-Registers and removes event handlers and their Handles.-Runs the applications event loop.
Collaborator -Handle set.-Event Handlers.-Event Demultiplexer.
Class Reactor
Acceptor Sequence Diagram
Connector pattern
Acceptor – Connector pattern
•Acceptor-Connector is one of the most important of design patterns.• Provides reusability – Strict separation of connection handling ensures passive/active connection establishment procedures to be written once and run in any framework.• Efficiency – Can be used to establish connections with a large number of hosts asynchronously and efficiently over long-latency wide area networks.
Uses 1)Web-browsers. 2) JACE – Java ACE has built – in Acceptors , Connectors
and SvcHandlers to implements core aspects of the Acceptor – Connector pattern.
3) Real-life examples such as managers communicating through their secretaries . Secretaries act as acceptors/connectors , while Managers act as service handlers.
Putting it all together
inThe ACE Framework
Concurrency PatternsPatterns of Interest
Half-Sync/Half-Async – Decouples synchronous and asynchronous service processing in concurrent systems.
Monitor Object – Synchronizes concurrent method execution to ensure that only one method at time runs within an object . This also helps in scheduling processes. Eg – Readers/Writers problem.
Half-Sync/Half – Async Pattern Problem
Two forces to be resolved during the software development process
1) Synchronous processing simplicity and asynchronous processing complexity (and efficiency)
2) Architectures must be able to exploit both the
efficiency of asynchronous operations and the simplicity of synchronous operations.
Solution
• Separate synchronous and asynchronous layers. Synchronous operations such as file transfers ,write() and read() operations are done in the synchronous layers.
• If these two layers need to communicate , then they do so through messages that are queued up in the queuing layer
Synch Service 1 Synch Service 2 Synch Service 3
Queue
Async Service External Event Source
Queueing layer
Synch Service layer
Asynch Service layer
Synchronization Patterns
Strategized Locking – Parameterized synchronization patterns that protect a component’s critical sections from concurrent access.
Uses – File cache access. Eg . File access may be required by many applications at once. Many applications may require access to the file cache. The component (file cache) must contain multiple synchronization mechanisms to support various applications that implement different synchronization primitives.
CRC cards
• CRC cards are a method to simplify object-oriented programming
• Each card explains a class ,its responsibilities and its collaborators.
• Each member of the design team has a card or a set of cards for which he/she is responsible.
Important links for Networking patterns ACE – The Adaptive Communications Environment
- http://www.cs.wustl.edu/~schmidt/ACE.html
JACE ( JAVA ACE) – A set of reusable classes which are widely used for the development of networking software.
- http://www.cs.wustl.edu/~schmidt/ACE-overview.html
Documentation - http://www.cs.wustl.edu/~schmidt/ACE-documentation.html
ACE applied to CORBA – A description and few tutorials on the ACE appiled to ORB
- http://www.cs.wustl.edu/~schmidt/TAO.html
To Summarize •Patterns help in tapping the knowledge of software development .• Patterns applied to networking simplify the process of software development.
Further developments
Patterns can be combined together to give pattern languages eg . Reactor – Acceptor – Connector.
Reactor Acceptor-Connector
Active Object Monitor Object
Conclusion contd..Pattern languages ??
•A pattern language guides a designer by providing workable solutions to all of the problems known to arise in the course of design.
•A solution is arrived at by combining a set of patterns to solve commonly encountered problem.
•Alternatively ,if we observe a set of patterns being always used in a particular context ,then we can say that we have a pattern language for that context.
•An example of applying pattern languages (using Acceptor-Connector-Reactor) for solving a class of problems (network routing) is described here.
http://www.cs.wustl.edu/~schmidt/PDF/TAPOS-00.pdf