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 IF age > 29 GOTO PRINT “You are still a baby!” GOTO PRINT “You are ready for retirement!” 80 END

BASIC The GOTO problem What on earth does line 2970 do? Code in single continuous block Great for “K-LOCers” Unstructured Not reusable Not “easy to use”!

Structure in language Program structure composed of sub- structures 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 int add(int, int) Math multiply add

Complexity Need for modularity

Multi-tier applications Split application logic Reduce cost, improve maintainability Improve scalability Use multiple partners three-tier application client app serverDB server

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 Math add y=Math.add(a,b) Internet

RPC Client Call Client Stub Pack and send parameters Receive and unpack parameters Pack and send results Execute procedure Return Receive and unpack results Server StubServer Message

Client Java object Java RMI Remote Java object TCP Java Remote Method Invocation

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 –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 Skeleton Remote object Stub Client object

Remote Interfaces and Stubs Remote Interface Stub Remote Object (Server) ClientSkeleton implements

RMI System Architecture Client Virtual Machine Client Server Virtual Machine Stub Remote Object Skeleton Registry Virtual Machine “Fred” Server

RMI System Architecture Client Virtual Machine Client Server Virtual Machine Stub Remote Object Skeleton Registry Virtual Machine “Fred” Server Server Creates Remote Object 2. Server Registers Remote Object

RMI System Architecture Client Virtual Machine Client Server Virtual Machine Stub Remote Object Skeleton Registry Virtual Machine “Fred” Server 4 3. Client requests object from Registry 4. Registry returns remote reference (and stub gets created) 3

RMI System Architecture Client Virtual Machine Client Server Virtual Machine Stub Remote Object Skeleton Registry Virtual Machine “Fred” Server 6 5. Client invokes stub method 6. Stub talks to skeleton 7. Skeleton invokes remote object method 57

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) Adder.class (interface classfile) javac AdderImpl.java (remote class) AdderImpl.class (classfile) javac rmic AdderImpl_Skel.class (skeleton classfile) 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 VM- specific 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 Java RMI App 1App 2 Enterprise B COM App 1App 2 Enterprise C CORBA App 1App 2 COM/RMI bridge COM/CORBA bridge

Enterprise A Java RMI App 1App 2 Enterprise B COM App 1App 2 Enterprise C CORBA App 1App 2 COM/RMI bridge COM/CORBA bridge protocol change

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”