Date post: | 21-Jan-2016 |
Category: |
Documents |
Upload: | sophie-moore |
View: | 217 times |
Download: | 0 times |
September 24, 2009 COMS W4156 1
COMS W4156: Advanced Software Engineering
Prof. Gail Kaiser
http://bank.cs.columbia.edu/classes/cs4156/
September 24, 2009 COMS W4156 2
Topics covered in this lecture
• COM + MTS• COM+• .NET: includes new improved COM+ as
EnterpriseServices
September 24, 2009 COMS W4156 3
COM + MTS
September 24, 2009 COMS W4156 4
Microsoft Transaction Server (MTS)
• Enables the transactional requirements of each component to be set administratively, so components can be written separately and then grouped together as needed to form a single transaction
September 24, 2009 COMS W4156 5
What Transactional Requirements?
• Many applications write to some database or other data repository
• An application that makes more than one change to a database may want to group those changes into a single unit – called a transaction
• The goal is to make sure that either all of those changes take place or that none of them do—a mix of success and failure isn’t possible
September 24, 2009 COMS W4156 6
What is a Transaction?
• “ACID” properties– Atomicity (all or nothing)– Consistency (no integrity constraints violated)– Isolation (no one else sees intermediate states,
more formally = serializability)– Durability (persistence = failure recovery)
• Component model frameworks generally only concerned with atomicity and durability
September 24, 2009 COMS W4156 7
Handling Transactions within One Data Source
• If all the data accessed are contained in a single database, the database itself probably provides transactions
• The programmer need only indicate when a transaction begins and when it ends
• The database will make sure that all data accesses within these boundaries are either committed or rolled back
September 24, 2009 COMS W4156 8
Handling Transactions Across Multiple Data Sources
• The problem gets harder when an application accesses data contained in more than one database or involves other data resource managers such as a message queue
• It’s probably not possible for the transaction support built into any one of those systems to coordinate the commitment or roll-back of all data accesses
• Need some kind of independent transaction coordinating service
September 24, 2009 COMS W4156 9
What does the Transaction Coordinating Service do?
• Two-Phase Commit • First phase: transaction coordinator asks every
resource manager (e.g., database) involved in the transaction if it’s prepared to commit
• Second phase:– If every resource manager says yes, then the transaction
coordinator tells each one to commit– If one or more of the resource managers involved in this
transaction is unable or unwilling to commit (or does not respond within a timeout period), the transaction coordinator tells all of them to roll back the transaction
September 24, 2009 COMS W4156 10
MTS Executive and Distributed Transaction Coordinator (DTC)
• Invisible to a client, client sees just an ordinary COM object exposing some number of interfaces
• Executive intercepts every call the client makes on the objects it controls
• DTC manages the two-phase commit
September 24, 2009 COMS W4156 11
MTS Application Structure
September 24, 2009 COMS W4156 12
Two-Phase Commit
• OLE = Object Linking and Embedding
September 24, 2009 COMS W4156 13
Context Object
• Every object involved in a transaction is associated with a context object
• If a transaction needs to span the functions of multiple different objects, then same context object coordinates the activities of all of those objects
• Allows the transaction semantics to be separated from the application code
September 24, 2009 COMS W4156 14
Automatic Transactions
• In traditional transaction systems, the application code indicates when a transaction begins and ends
• MTS also supports automatic transactions, allowing business logic to remain unaware of when transactions start and end
September 24, 2009 COMS W4156 15
Transaction Semantics Defined Declaratively
• Transaction semantics declared when components are assembled into an application package
• Each component is assigned a transaction attribute, one of four values:– Required – Requires New – Supported – Not Supported
September 24, 2009 COMS W4156 16
Transaction Options
• REQUIRED - The component must execute within the context of a transaction, although it does not care where the transaction context originates– If the caller has a transaction (context object), then
the called component will use the existing transaction
– If the caller does not have a transaction, then MTS automatically creates a new transaction context for the component
September 24, 2009 COMS W4156 17
Transaction Options
• REQUIRES NEW - indicates that the component must always establish its own transaction context
• Regardless of whether or not the calling application has a transaction context, MTS automatically creates a new transaction context object for the component
September 24, 2009 COMS W4156 18
Transaction Options
• SUPPORTED - indicates that the component does not care whether or not there is a transaction context in place
• NOT SUPPORTED - indicates that the component cannot support a transaction
September 24, 2009 COMS W4156 19
Commit or Abort
• The component operating on the database can tell the MTS executive when its task is complete– Everything has gone just fine and the transaction is ready
to be committed – the component calls IObjectContext::SetComplete (or just returns)
– Something has gone wrong, perhaps one attempt to access data resulted in an error, and the entire transaction should be rolled back – the component calls IObjectContext::SetAbort (or just crashes, hangs, etc.)
September 24, 2009 COMS W4156 20
Coordination of Multi-Component Transactions
• Calling SetComplete does not necessarily mean that the transaction will be committed right then
• If this component implements all the work required for an entire transaction, then MTS will perform the commit
September 24, 2009 COMS W4156 21
Coordination of Multi-Component Transactions
• But this component may be part of a group of components, all of which collectively participate in a single transaction
• Each component will call SetComplete (or terminate) when its work is done, but MTS won’t begin the commit process until all components within the transaction have completed successfully
• The code for the component looks the same in either case
September 24, 2009 COMS W4156 22
And a few other services…
September 24, 2009 COMS W4156 23
Just-In-Time (JIT) Activation• Also known as deferred activation• When a client makes a call to an object to create an instance,
COM provides that client a reference to a context object instead of a reference to the object
• Client gets a real reference to the object, and the object is activated, only when client calls a method of that object
• Object deactivated when method returns and reactivated when next method called
• Deactivated object releases all resources, including locks on data stores
• Allows server resources to be used more productively
September 24, 2009 COMS W4156 24
Object Pooling• Recycling of objects• When a client releases an object that supports object pooling, or
such an object is deactivated, instead of destroying that object completely, COM+MTS recycles it
• When another client requests or reactivates the same kind of object, COM+MTS gives an instance from the pool
• Since these component instances are already loaded in memory (up to maximum size of pool), they are immediately available for use
• If you intend to make only one call at a time on a pooled object, it is a good idea to enable JIT activation with object pooling; if you intend to get a reference and make multiple calls on it, using object pooling without JIT activation may result in better performance.
September 24, 2009 COMS W4156 25
Connection Pooling
• Opening and closing connections to a database can be time-consuming
• Reuse existing database connections rather than create new ones
• A resource dispenser caches resources such as ODBC (Open DataBase Connectivity) connections to a database, allowing components to efficiently reuse them
September 24, 2009 COMS W4156 26
Role-Based Security
• “Role” = a logically related group of users that share the same permissions to access a defined subset of an application’s functionalities
• Assign different permissions for different roles on a class, interface or method
• Can set either administratively or via programming• Don’t need to write security-related logic into
components (but can do so if desired)
September 24, 2009 COMS W4156 27
So How Does MTS Fit With COM?
September 24, 2009 COMS W4156 28
MTS Extends COM to 3-tier Architecture
September 24, 2009 COMS W4156 29
Client-Server Architecture
Client Server
September 24, 2009 COMS W4156 30
2-tier Architecturewith Basic Component Middleware
Client Server
Componentmiddleware
September 24, 2009 COMS W4156 31
3-Tier Architecturewith Component Services Middleware
Client
Componentservicesmiddleware
Database
Application logic com
ponents
LDA
PD
ocument
Storage
September 24, 2009 COMS W4156 32
COM+
September 24, 2009 COMS W4156 33
COM+
September 24, 2009 COMS W4156 34
Load Balancing
• Scalability: network traffic and number of clients should not affect performance of an application (e.g., response time, throughput)
• Load balancing distributes client calls across a server cluster transparently to the application
• Components to be load-balanced configured on per-class basis at deployment
September 24, 2009 COMS W4156 35
COM+ Router
• When a client requests a specific component, it first connects to a load balancing router (itself possibly a cluster)
• Router polls the cluster application servers for timing data (e.g., every 200ms)
• Router chooses a server based on lightest server load and availability
• Modified round-robin algorithm
September 24, 2009 COMS W4156 36
Service Control Manager (SCM)
• Router’s SCM forwards the activation request to the selected server's SCM
• If the instantiation of the object fails, the router moves to the next server in the round-robin list
• Continues until a valid interface pointer is returned to the client
• From this point, all communication occurs directly between the client and the server that handled the request
September 24, 2009 COMS W4156 37
Microsoft Message Queue Server (MSMQ)
• Client can execute (asynchronous) method calls, even if the server component is offline
• MSMQ records and stores method calls automatically whenever the server object is unavailable
• Useful for online applications that must be completed (online banking, air reservation system, etc.)
September 24, 2009 COMS W4156 38
Disconnected Applications
• Increasing use of laptops, notebooks and palmtop computers has created a need for applications that service disconnected clients or mobile users
• In a queued system, these users can continue to work when not connected to the application server, and later connect to the databases or servers to process their requests
• For example, a salesperson can take orders from customers and later connect to the shipping department to process those orders
September 24, 2009 COMS W4156 39
Component Availability
• In synchronous processing applications, if just one component of a compound activity is not available—perhaps because of server overload or networking problems—the entire process is blocked and cannot complete
• An application using the Queued Components service separates the activity into actions that must be completed now and those that can be completed at a later time
September 24, 2009 COMS W4156 40
Client/Server Decoupling
September 24, 2009 COMS W4156 41
Message Queuing
• A queue is a storage area that saves messages for later retrieval
• Provides a mechanism for connectionless communication - sender and receiver are not connected directly and communicate only through queues
• Previously, in-depth knowledge of marshaling needed to queue, send and receive asynchronous messages
• Queued Components service automatically marshals data as messages
September 24, 2009 COMS W4156 42
Message Reliability
• Message Queuing uses database techniques to help protect data in a robust way
• Built-in support for transactions• In the event of a server failure, Message Queuing
ensures that transactions are rolled back so that messages are not lost and data is not corrupted
September 24, 2009 COMS W4156 43
Server Scheduling
• An application using queued components is well suited to time-shifted component execution, which defers non-critical work to an off-peak period
• Analogous to traditional batch mode processing• Similar requests can be deferred for contiguous
execution by the server rather than requiring the server to react immediately to a wide variety of requests
September 24, 2009 COMS W4156 44
Event-based computing
September 24, 2009 COMS W4156 45
Original COM Events
• Choice between two (similar) techniques
– Interface callback mechanism
– Connectable Objects
September 24, 2009 COMS W4156 46
Interface Callbacks
• Client implements a COM interface described by the event publisher component, and passes to the component a pointer to this interface
• Client then receives notifications (i.e., callbacks) when the component calls a method through the interface implemented by the client code
• Callbacks is a technique used widely in GUI processing
September 24, 2009 COMS W4156 47
Connectable Objects
• Also known as connection points• Exchange of an interface pointer implemented by the
client (invoked to notify of an event)• Uses COM's standard IConnectionPoint
interface (and other related interfaces)• Connect (Advise) and disconnect (Unadvise)• Enumerate connections (EnumConnections)
September 24, 2009 COMS W4156 48
Example
September 24, 2009 COMS W4156 49
COM Events Problems
• Only a series of interfaces - developers still have to write the code to implement these interfaces
• Implementing a complex application making heavy use of events may require complex coding to handle multiplexing events, multiple connected clients, circular references, deadlock situations, etc.
• Client and component lifetimes are tightly coupled through the exchanged interface pointer - the client must be running and connected to receive events
• It is difficult to get between a component instance and its clients to monitor the connection, provide trace information, etc.
September 24, 2009 COMS W4156 50
COM+ Events
• Publish-subscribe model rather than request-reply• Publishers are not tightly bound to their subscribers
and in most cases don't even know who they are• Publishers do not block when firing an event• Subscribers do not bind themselves directly to
publishers - an intermediary object manages communication between a publisher and its subscribers
September 24, 2009 COMS W4156 51
Event Class
• An event class component sits between a publisher of information and any potential subscribers
• COM+ Events system provides the actual implementation of this intermediate object
• Eliminates the need to directly pass an interface pointer through an Advise method
• Publisher and subscriber lifecycles no longer tightly coupled
September 24, 2009 COMS W4156 52
Publisher
• The event class looks like a subscriber to the publisher
• When a publisher wants to “fire” an event, it creates an instance of the event class, calls the appropriate method, and then releases the interface (as in queued components)
• The runtime then determines how and when to notify any subscribers
September 24, 2009 COMS W4156 53
Subscriber
• To receive events, need only implement the event interface
• Registers with the COM+ Events service by creating a subscription object, through the IEventSubscription interface
• The component will be (activated and) notified as events are published
• Either persistent or transient subscriptions
September 24, 2009 COMS W4156 54
Example
September 24, 2009 COMS W4156 55
Example
September 24, 2009 COMS W4156 56
Improved COM+ Events
• Provides a “third-party” publish-subscribe environment: Once an event class is created, anyone can become a publisher or subscriber of the events
• Supports a rich filter mechanism: one can filter at the publisher method level – IPublisherFilter allows event class object to decide which subscribers receive a particular event, or at the method parameter level – ISubscribeControl supports a complex criteria string per subscriber
September 24, 2009 COMS W4156 57
Filtering Example
September 24, 2009 COMS W4156 58
And more…
September 24, 2009 COMS W4156 59
COM+ Summary• COM-based services and technologies first
released in Windows 2000• Automatically handles difficult programming
tasks such as resource pooling, disconnected applications, distributed transactions, event notification, etc., often administratively (manually or scripted)
• Also supports .NET developers and applications through .NET’s Enterprise Services
September 24, 2009 COMS W4156 60
What Is Meant By Administratively?
September 24, 2009 COMS W4156 61
September 24, 2009 COMS W4156 62
September 24, 2009 COMS W4156 63
.NET
September 24, 2009 COMS W4156 64
What is .NET?
• An object-oriented software development platform, with– peer to peer multi-language interoperability – common intermediate language (CIL)– common language runtime (CLR)– common data representation based on XML
• The C# language is the most comfortable for .NET, but not the only one and not mandatory
September 24, 2009 COMS W4156 65
Why do they call it “.NET”?
• “I don't know what they were thinking. They certainly weren't thinking of people using search tools. It's meaningless marketing nonsense.” [Andy McMullan]
September 24, 2009 COMS W4156 66
How Does Multi-Language Support Work?
• A compiler from any supported language compiles an application into CIL (also referred to as MS IL – Microsoft Intermediate Language)
• The compiler also generates metadata in XML – information on the types and named entities (classes, methods, fields, etc.) defined and used in the application
• At runtime, the CIL code is Just-in-Time (JIT) compiled into the target platform’s native code
• The CLR uses the metadata to perform runtime checks for type-safety and security (“managed code”)
September 24, 2009 COMS W4156 67
Attributes
• Metadata attributes attach some data to a class or method, which can be accessed via reflection, e.g., [serializable]
• Context attributes provide an interception mechanism whereby instance activation and method calls can be pre- and/or post- processed
September 24, 2009 COMS W4156 68
Common Language RuntimeExecution Model
CLR
VBSource code
Compiler
C++C#
Assembly AssemblyAssembly
Operating System Services
MSIL
Common Language Runtime JIT Compiler
Compiler Compiler
Native code
ManagedCode
ManagedCode
ManagedCode
UnmanagedCode
CLR Services
Ngen
September 24, 2009 COMS W4156 69
What does “managed” mean?
• Managed code: .NET provides several core run-time services to the programs that run within it, e.g., exception handling and security - for these services to work, the code must provide a minimum level of information to the runtime
• Managed data: Data that is allocated and freed by the .NET runtime's garbage collector
• Managed classes: A C++ class can be marked with the __gc keyword - then memory for instances of the class are managed by the garbage collector and the class can interoperate with classes written in other CLR languages, e.g., inherit from a VB class (also restrictions, e.g., a managed class can only inherit from one base class)
September 24, 2009 COMS W4156 70
What is an “assembly”?
• A logical .exe or .dll, can be an application (with a main entry point) or a library
• Consists of one or more files (dlls, exes, html files, etc.), and represents a group of resources, type definitions, implementations of those types, and references to other assemblies
• These resources, types and references are described in a block of data called a manifest - part of the assembly, making it self-describing
• Assemblies often referred to as “components”: CLR in a sense replaces COM
September 24, 2009 COMS W4156 71
Private vs. Shared Assemblies
• A private assembly is normally used by a single application, and is stored in the application's directory
• A shared assembly is intended to be used by multiple applications, and is normally stored in the global assembly cache (GAC) but can be stored elsewhere
• Assemblies find each other (outside the GAC) by searching directory paths
September 24, 2009 COMS W4156 72
Remoting• When a client creates an
instance of the remote type, the .NET infrastructure creates a proxy object that looks exactly like the remote type to the client.
• The client calls a method on that proxy, and the remoting system receives the call, routes it to the server process, invokes the server object, and returns the return value to the client proxy - which returns the result to the client.
September 24, 2009 COMS W4156 73
Remoting
• Send messages along channels, e.g., TCP or HTTP
• Multiple serialization formats, e.g., SOAP (for HTTP) or binary (for TCP, replacing DCOM)
• Distributed garbage collection of objects is managed by “leased based lifetime” – when that time expires the object is disconnected from the .NET runtime remoting infrastructure unless in the interim renewed by a successful call from the client to the object (or explicit renewal by client)
September 24, 2009 COMS W4156 74
Remote Invocations
• SingleCall: Each incoming request from a client is serviced by a new object
• Singleton: All incoming requests from clients are processed by a single server object
• Client-activated object: The client receives a reference to the remote object and holds that reference (thus keeping the remote object alive) until it is finished with it
September 24, 2009 COMS W4156 75
So Where’s the Component Services?
September 24, 2009 COMS W4156 76
.NET Serviced Components
• Classes in the System.EnterpriseServices namespace wrap COM+ and make it much easier to build COM components
• COM+ services can be used by .NET components derived from the ServicedComponent class using the System.EnterpriseServices namespace
• Must be registered with the COM+ catalog• Can also use COM+ services outside components
September 24, 2009 COMS W4156 77
Example
September 24, 2009 COMS W4156 78
.NET vs. COM+
• No IDL (Interface Definition Language) files, the compiler generates the assembly metadata and dependencies are captured during compilation (in manifests)
• No GUIDs (globally unique identifiers), instead uses scoping based on namespaces and “strong names” (unique digital signature using an encryption key)
• Doesn’t rely on registry, reduces DLL Hell
September 24, 2009 COMS W4156 79
Final Notes
September 24, 2009 COMS W4156 80
Teams Announcement
• Teams are posted on the website team page
• Project Concept due September 29th
September 24, 2009 COMS W4156 81
Upcoming Deadlines
• Project concept feedback by October 6th First iteration begins October 6th
• First Iteration Plan due October 13th
• First Iteration First Progress Report due October 20th
September 24, 2009 COMS W4156 82
COMS W4156: Advanced Software Engineering
Prof. Gail Kaiser
http://bank.cs.columbia.edu/classes/cs4156/