Download ppt

COP 4991
Component Based Software
Development
Lecture #2
Distributed and Web Computing
Onyeka Ezenwoye
Acknowledgement
Lou Somers
Alex Chaffee
BASIC
Beginners All-purpose Symbolic Instruction
Code
John Kemeny and Thomas Kurtz, 1963
General-purpose language
Easy to use?
BASIC
10 REM a great BASIC program
20 PRINT “Hello There!”
30 INPUT “Please enter your age:” age
40 IF age > 1 AND age < 21 GOTO 60
50 IF age > 29 GOTO 70
60 PRINT “You are still a baby!” GOTO 80
70 PRINT “You are ready for retirement!”
80 END
BASIC
Unstructured
Not reusable
Not “easy to use”!
• The GOTO problem
• What on earth does line 2970 do?
• Code in single continuous block
• Great for “K-LOCers”
Structure in language
Program structure composed of substructures
Essentially functions and subroutines
y = add(a,b)
x = multiply(y, z)
Single point of entry,
multiple points of exit.
Promote modularity
Object-oriented programming
More sophisticated form of modularity
The world is made of objects
Think objects, not procedures
y = Math.add(a,b)
x = Math.multiply(y,z)
Program is a collection of objects (class
libraries)
Interface
Communication boundary between two
entities (software)
Abstraction about software component
Well defined entry point
Enables interaction
Method signatures
add
Math
int add(int, int)
multiply
Complexity
Need for modularity
Multi-tier applications
Split application logic
Reduce cost, improve maintainability
Improve scalability
Use multiple partners
client
app server
DB server
three-tier application
Client-server
Enables separation between modules
A request-response interaction style.
Uniform interface: resources accessed with a
generic interface (e.g., HTTP GET, POST).
Named resources - the system is comprised of
resources which are accessed using a URL.
Easier to build, maintain and extend components
Standardization
Interoperability
HTTP (Hypertext Transfer Protocol)
Request/response communication protocol
between client and server.
Est. TCP connection to port 80 on server
HTTP GET
– Requests a resource, identified by the URL
HTTP POST
– Sends data to be processed
RPC (remote procedure call)
The act of invoking a method over a network
Remote component integration
Client-Server message passing
Location transparent
Tight coupling between client and remote
applications
y=Math.add(a,b)
Internet
add
Math
RPC
Client
Call
Client Stub
Pack and send
parameters
Receive and
unpack results
Message
Message
Server Stub
Server
Receive and
unpack
parameters
Execute
procedure
Pack and
send
results
Return
Java Remote Method Invocation
Client
Java
object
TCP
Java RMI
Java RMI
Remote
Java
object
Remote Objects
Remote Objects
– Live on server
– Accessed as if they were local
Registries
Name and look up remote objects
Servers can register their objects
Clients can find server objects and obtain a
remote reference
A registry is a running process on a host
machine
Stubs and Skeletons
Stub
Client
object
– lives on client
– pretends to be remote object
Skeleton
–
–
–
–
lives on server
receives requests from stub
talks to true remote object
delivers response to stub
Stub
Skeleton
Remote
object
Remote Interfaces and Stubs
Remote Interface
implements
Client
Stub
implements
Skeleton
Remote Object
(Server)
RMI System Architecture
Client Virtual Machine
Server Virtual Machine
Client
Remote
Object
Stub
Skeleton
“Fred”
Registry Virtual Machine
Server
RMI System Architecture
1. Server Creates Remote Object
Virtual
Machine
2. ServerClient
Registers
Remote
Object
Client
Server Virtual Machine
Remote
Object
1
Stub
Skeleton
Server
2
“Fred”
Registry Virtual Machine
RMI System Architecture
Client Virtual Machine
Client
Remote
3. Client requests object from Registry
Object
4. Registry returns remote reference
(and stub gets created)
Skeleton
Stub
3
Server Virtual Machine
Server
4
“Fred”
Registry Virtual Machine
RMI System Architecture
Client Virtual Machine
Server Virtual Machine
Client
5
7
Remote
Object
6
Stub
Skeleton
5. Client invokes stub method
6. Stub talks to skeleton
7. Skeleton
invokes remote object
“Fred”
method
Registry Virtual Machine
Server
Creating Remote Objects
Define a Remote Interface
– extends java.rmi.Remote
Define a class that implements the Remote
Interface
– extends java.rmi.RemoteObject
– or java.rmi.UnicastRemoteObject
Remote Interface Example
import java.rmi.*;
public interface Adder
extends Remote
{
public int add(int x, int y)
throws RemoteException;
}
Remote Class Example
import java.rmi.*;
import java.rmi.server.*;
public class AdderImpl extends UnicastRemoteObject
implements Adder
{
public AdderImpl() throws RemoteException
{
}
public int add(int x, int y)
throws RemoteException
{
return x + y;
}
}
Compiling Remote Classes
Compile the Java class
– javac
• reads .java file
• produces .class file
Compile the Stub and Skeleton
– rmic
• reads .class file
• produces _Skel.class and _Stub.class
Compiling Remote Classes
(Diagram)
Adder.java
(interface)
javac
AdderImpl.java
(remote class)
javac
Adder.class
(interface classfile)
AdderImpl.class
(classfile)
AdderImpl_Skel.class
(skeleton classfile)
rmic
AdderImpl_Stub.class
(stub classfile)
Registering Remote Classes
start the registry
– running process
Unix:
rmiregistry &
Windows:
start /m rmiregistry
Create the server
Creates a new instance of the remote object
Registers it in the registry with a unique
name
That’s it
RMI Server Example
try {
AdderImpl adder = new AdderImpl();
Naming.rebind("adder", adder);
System.out.println("Adder bound");
}
catch (RemoteException re) {
re.printStackTrace();
}
catch (MalformedURLException me) {
me.printStackTrace();
}
Launch the Server
% java AdderServer &
Adder bound
Server Logging
invoke from command line
java
-Djava.rmi.server.logCalls=true
YourServerImpl
or enable inside program
RemoteServer.setLog(System.err);
Creating an RMI Client
Install a Security Manager
– to protect from malicious stubs
Find a registry
– use java.rmi.Naming
Lookup the name, returns a reference
Cast the reference to the appropriate
Remote Interface
Just use it!
RMI URLs
rmi://host[:port]/name
default port is 1099
Specifies hostname of registry
can also use relative URLs
– name only
– assumes registry is on local host
RMI Client Example
Adder a = (Adder)
Naming.lookup(“rmi://localhost/add
er");
int sum = a.add(2,2);
System.out.println("2+2=" + sum);
Object Serialization
aka Persistence
saves the state (data) of a particular instance
of an object
serialize - to save
unserialize - to load
Java Serialization
writes object as a sequence of bytes
writes it to a Stream
recreates it on the other end
creates a brand new object with the old data
Not All Objects Are Serializable
Any object that doesn’t implement
Serializable
Any object that would pose a security risk
– e.g. FileInputStream
Any object whose value depends on VMspecific information
– e.g. Thread
Limitations of RMI
Java-only
Middleware
“The glue which connects objects which are
distributed across multiple heterogeneous
computer systems”
“A software layer that serves to shield the
application of the heterogeneity of the underlying
computer platforms and networks”
Distribution Middleware
Middleware goals
Integrate existing components into a distributed
system
– Components may be off-the-shelf
– Components may have incompatible requirements for hardware
and OS platforms
– Scalability requires distribution (not centralized or client server).
Resolve heterogeneity
– Facilitate communication and coordination of distributed
components
– Build systems distributed across a local area network, the internet
– Future: adaptive, reconfigurable
Requirements of middleware / 1
Network communication
– Need higher level primitives than network operating system
primitives
– Transport complex data structures over the network (marshalling /
unmarshalling)
Coordination
– Three models:
• Synchronous: client waits for result
• Deferred synchronous: client asks for result (e.g. by polling)
• Asynchronous: server initiates result
– Group requests
– Component activation / deactivation
– Concurrent requests
Requirements of middleware / 2
Reliability
– Error detection and correction mechanisms on top of
network protocols
Scalability
– Access to a component independent of whether it is
local or remote
– Migration transparency
– Replication transparency
Heterogeneity
– Primitive data encoding
– Different programming languages
Middleware categories
Transactional middleware
– Offers a tuple abstraction (SQL)
– Distributed transaction processing (DTP protocol)
Message oriented (MOM)
– Offers a mailbox abstraction
– Asynchronous messages
Procedural (RPC)
– Offers a procedure abstraction
– Synchronous client / server interaction
Object and component
– Offers an object abstraction
– (A)synchronous client / server interaction
Transactional middleware / 1
Transactions on distributed relational database
– Two-phase commit protocol to implement distributed
transactions
Examples
– IBM CICS
– BEA Tuxedo
– LDAP (simple protocol to access remote directories, no
transactions)
Transactional middleware / 2
Network communication
–
Client and servers may reside on different hosts
Coordination
–
Synchronous and asynchronous
Reliability
–
–
–
–
–
–
DTP (Distributed Transaction Protocol): two phase commit
ACID properties:
Atomic: transaction is either complete or not
Consistent: system always in consistent state
Isolation: transaction is independent of other transactions
Durable: committed transaction survives system failures
Scalability
–
Load balancing and replication of server components
Heterogeneity
–
–
Different hardware and operating systems platforms
No data heterogeneity
Message oriented middleware / 1
Exchange messages between components
– “Mailbox”
Examples
– Java Message Queue
– IBM MQSeries
Message oriented middleware / 2
Network communication
– Client sends message, server replies with result
– Well suited for event notification and publish / subscribe
Coordination
– Asynchronous
– Synchronous has to be coded by client
Reliability
– Message queues are stored on persistent memory
– At-least-once semantics possible
Scalability
– Local / remote differs
Heterogeneity
– Marshalling code has to be written by hand
Procedural middleware / 1
Remote procedure calls (RPC)
– Procedures can be called across the network
Examples
– Unix RPC’s
– DCE RPC (Distributed Computing
Environment)
– Windows RPC’s
– XML-RPC
Procedural middleware / 2
Network communication
– Server exports parameterized procedures
– Clients call these across the network
– Marshalling and unmarshalling by client and server stubs
(generated by the compiler)
Coordination
– Synchronous interaction between one client and one server
– Startup on demand possible (daemon needs a table that maps RPC
names to program locations in the file system)
Reliability
– At-most-once semantics (exception if RPC fails)
No scalability
Heterogeneity
– Can be used between different programming languages
– Across different hardware and OS platforms
Object middleware / 1
Objects are available across the network
Examples
– Corba
– COM, DCOM
– Java RMI, Enterprise Java Beans
Enterprise A
App 1
Enterprise B
App 2
App 1
COM/RMI
bridge
Java RMI
Enterprise C
App 2
App 1
App 2
COM/CORBA
bridge
COM
CORBA
Enterprise A
App 1
Enterprise B
App 2
App 1
COM/RMI
bridge
Java RMI
Enterprise C
App 2
App 1
App 2
COM/CORBA
bridge
COM
CORBA
Reading List
Patricia Soares, “On Remote Procedure Call ”
Birrell et. al., “Implementing Remote Procedure Calls”
Eugster et. al., “The Many Faces of Publish/Subscribe”
Talarian Corp., “Talarian: Everything You Need Know
About Middleware”
David B akken,”Middleware”
Bertrand Meyer, “The Reusability Challenge”
Ted Lewis, “Where is Client/Server Software Headed?”
Scot Lewandowski,”Frameworks for Component-Based
Client/Server Computing”