4005-730 -- Distributed Systems

Alan Kaminsky

•

Department of Computer Science

•

Rochester Institute of Technology

•

4486 + 2220 = 6706

Home Page

Distributed Systems

4005-730-01

Spring Quarter 2013

Course Page

4005-730 Distributed Systems
Lecture Notes -- Module 2. Distributed Object Systems

Prof. Alan Kaminsky
Rochester Institute of Technology -- Department of Computer Science

The Big Picture

A normal method call
- Calling object → Method (arguments) → Target object
- Calling object ← Return value ← Target object
  - or -
- Calling object ← Thrown exception ← Target object
A remote method call
- Calling object → Method (arguments) → Client-side proxy object
- Client-side proxy object → Network message → Server-side proxy object
- Server-side proxy object → Method (arguments) → Target object
- Server-side proxy object ← Return value ← Target object
- Client-side proxy object ← Network message ← Server-side proxy object
- Calling object ← Return value ← Client-side proxy object
  - or -
- Server-side proxy object ← Thrown exception ← Target object
- Client-side proxy object ← Network message ← Server-side proxy object
- Calling object ← Thrown exception ← Client-side proxy object
Another possibility
- Calling object → Method (arguments) → Client-side proxy object
- Client-side proxy object → Network message → Server-side proxy object
- Client-side proxy object ← Network message ← Server-side proxy object
- Calling object ← RemoteException ← Client-side proxy object
Still another possibility
- Calling object → Method (arguments) → Client-side proxy object
- Calling object ← RemoteException ← Client-side proxy object
Terminology
- Calling object
- Target object
- Remote object
  - A target object that can be called from other processes
- Remote interface
  - An interface implemented by a remote object containing the methods that can be called from other processes
- Non-remote interface
  - An interface implemented by a remote object containing the methods that cannot be called from other processes
- Proxy object
- Client-side proxy object; stub
  - Implements the same remote interface(s) as the remote object
  - Does not implement the remote object's non-remote interfaces
- Server-side proxy object; skeleton
- Remote reference
  - A reference to a client-side proxy object for a remote object
- Remote exception
  - An exception thrown by the RMI system itself, not by the target object
- Marshalling
- Unmarshalling
Issues
- All remotely callable methods must be able to throw a remote exception
- If a remote exception happens, the target object may or may not have executed the method -- the calling object doesn't know

Java Platform Capabilities

Java RMI -- package java.rmi
- Interface java.rmi.Remote
- Class java.rmi.RemoteException
- Class java.rmi.MarshalledObject
Remote objects -- package java.rmi.server
- Class java.rmi.server.UnicastRemoteObject
Object Serialization -- package java.io
- Interface java.io.Serializable
- Class java.io.ObjectOutputStream
- Class java.io.ObjectInputStream
- Class java.rmi.MarshalledObject
Reflection -- package java.lang.reflect
- Dynamic proxies -- Class java.lang.reflect.Proxy
RMI Registry -- package java.rmi.registry
- Interface java.rmi.registry.Registry
- Class java.rmi.registry.LocateRegistry
- The rmiregistry command
- We won't be using the RMI Registry because it doesn't have the features we need to build distributed systems
Java RMI Tutorial. http://download.oracle.com/javase/tutorial/rmi/index.html

A Simple RMI Demonstration

Computer Science Course Library
- The Registry Server -- Package edu.rit.ds.registry
  - Class RegistryServer -- source
  - Class RegistryProxy -- source
- The Registry Monitor -- Package edu.rit.ds.registry.test
  - Class RegistryMonitor -- source
- The remote object launcher program, Start
  - Class Start -- source
The Demo: Factoring
- Package edu.rit.ds.demo
Steps in developing a distributed application using Java RMI:
1. Define remote interfaces
- Each remote interface must extend interface java.rmi.Remote
- Each remote interface method must throw java.rmi.RemoteException
- Interface FactorizerRef -- source
- Interface PrimeSequenceRef -- source
- Interface PrimeSequenceFactoryRef -- source
2. Define remote object implementation classes
- Each class should implement the appropriate remote interface(s)
- Each class should have a constructor (String[] args) for use by the Start program
  - Used to pass in command line arguments, like a Java main program
- The constructor should export the object
  - "Export" = make the object available to receive remote method calls
  - Call the UnicastRemoteObject.exportObject (this, 0) method
  - Returns a remote reference to the object
  - Cast the remote reference to the object's remote interface type
- If other objects need to find remote references to this remote object, the constructor should bind the exported object into the Registry Server
  - Be careful to bind the object after exporting it
  - Binding an exported object actually puts a remote reference to the object into the Registry Server, which is what we want
  - Alternatively, you can bind the remote reference into the Registry Server
  - Later we will study alternative forms of service discovery
- Class PrimeSequence -- source
- Class Eratosthenes -- source
- Class Matlock -- source
3. Write a client main program
- This is a normal Java main program, not a remote object
- Use the Registry Server to look up remote references to remote objects
- Cast each remote reference to the remote interface, not the implementation class
- Call methods on remote references just like local object references
- Class Factor -- source
4. Run the Registry Server using the Start program
5. Run the remote objects using the Start program
6. Run the client main program
Caveat: This RMI demo is not a particularly good distributed system; we have ignored most of the important issues

Marshalling and Unmarshalling

Marshalling = serialization of arguments or return value for a remote method invocation
Unmarshalling = deserialization of arguments or return value for a remote method invocation
Marshalling semantics
- Primitive types are passed by copy (same as normal method invocations)
- Objects and arrays are passed by copy (different from normal method invocations), except . . .
- Exported remote objects are passed by reference, i.e. remote reference (same as normal method invocations)
- Implications for the design of applications with distributed objects
Marshalling implementation
- Marshalling is the same as normal object serialization, except . . .
- If an exported remote object is marshalled, we serialize a client-side proxy for the object, not the object itself
- At the far end, we will deserialize the client-side proxy object and end up with a remote reference to the remote object
Unmarshalling implementation
- Unmarshalling is the same as normal object deserialization
MarshalledObject = a wrapper containing another object that has been serialized using marshalling semantics
- Used to transport an object in serialized form without automatically deserializing the object

Object Serialization

Turning an object into a byte stream
All arguments to, return values from, and exceptions thrown by remote methods must be serialized
Class java.io.ObjectOutputStream
- Output of bytes; output of primitive types; output of objects
- An object output stream can write to any underlying output stream -- a byte array, a file, a socket
Class java.io.ObjectInputStream
- Input of bytes; input of primitive types; input of objects
- An object input stream can read from any underlying input stream -- a byte array, a file, a socket
Interface java.io.Serializable
- Automatically decides how to convert an object to/from bytes
- Automatically handles superclasses
Interface java.io.Externalizable
- You have to write code yourself to convert an object to/from bytes
- You have to write code yourself to handle superclasses
- Usually results in significantly fewer bytes than Serializable
Java I/O Tutorial (including object serialization). http://download.oracle.com/javase/tutorial/essential/io/index.html

The Registry Server

The Registry Server
- Contains a mapping from names (strings) to objects
- Bind -- associate a name with an object
- Unbind -- dissociate a name from an object
- Lookup -- find the object, given the name
- Intended use: Remote objects bind themselves into the Registry Server with predefined names
- Clients look up names in the Registry Server and get back remote references to the remote objects
Architecture
- Server-side registry backend object -- exported remote object; uses RMI
- Client-side registry backend proxy object
- Registry Server object
- Registry Proxy object
- Bootstrapping protocol for getting registry backend proxy object
  - Registry Server listens to a well-known TCP port (9901)
  - Registry Proxy sets up a socket connection to Registry Server
  - Registry Server sends Registry Proxy a MarshalledObject containing the client-side registry backend proxy object
A design detail
- The registry backend stores objects in the map in marshalled form, as MarshalledObjects
- When binding, the Registry Proxy marshals the object (wraps it in a MarshalledObject) on the client side before sending it to the registry backend
- Why? Because storing the object in marshalled form means the Registry Server doesn't have to unmarshal the object, which means the object's classes don't have to be in the Registry Server's classpath
The "Backend" pattern
- Server side: Remote backend object
- Client side: "Smart proxy" object containing a remote reference to the backend object
- A method calls results in some processing first on the client side, then a remote method invocation to the server side, then maybe some more processing on the client side before returning
- We will encounter this pattern many times as we build distributed systems
Computer Science Course Library
- Package edu.rit.ds.registry
  - Interface RegistryBackendRef -- source
  - Class RegistryBackend -- source
  - Class RegistryServer -- source
  - Class RegistryProxy -- source

The P2Pedia System

P2Pedia System Version 1

Remote Events

The "pull" method of getting a remote object's status: polling
- Pros and cons
The "push" method of getting a remote object's status: remote events
- Pros and cons
Hybrid of polling + remote events
- Pros and cons
Registry Server remote events
Event filters
Computer Science Course Library
- Package edu.rit.ds
  - Class RemoteEvent -- source
  - Interface RemoteEventListener -- source
  - Class RemoteEventGenerator -- source
  - Interface RemoteEventFilter -- source
  - Class Lease -- source
- Package edu.rit.ds.registry
  - Class RegistryProxy -- source
P2Pedia System Version 2

Leasing and Fault Detection

Lease operation
- Lease renewals
- Lease expiration
- Lease cancellation
Detection of remote process failures via leases
Computer Science Course Library
- Package edu.rit.ds
  - Class Lease -- source

Web Services

Web services architecture
- Service providers (= servers)
- Service requesters (= clients)
- Service brokers (= registries)
Simple Object Access Protocol (SOAP)
- Remote method invocation protocol
- Uses XML encoding
- Service requester sends a remote method call request as a SOAP message to service provider
- Service provider sends a remote method call reply as a SOAP message to service requester
- SOAP messages often transported over HTTP (web)
Web Services Description Language (WSDL)
- Published by a service provider
- Uses XML encoding
- Describes the services the service provider offers
- Describes how to utilize those services, typically by doing remote method calls using SOAP
Universal Description, Discovery and Integration (UDDI)
- A standard for web service brokers (registries)
- Queried using SOAP
- Provides WSDL-encoded descriptions of service providers and their services
Finding the service broker (bootstrapping)
- Typically at the preconfigured end of the spectrum -- must know the service broker's host name
Web Services Example
The WSDL specification for Amazon Web Services: http://ecs.amazonaws.com/AWSECommerceService/AWSECommerceService.wsdl
Contrasting Web Services with Java RMI
- Web Services uses XML-encoded WSDL specifications for service interfaces
- Java RMI uses Java interfaces for service interfaces
- Web Services uses a service broker with UDDI to find services
- Java RMI uses a registry to find services
  - Sun's rmiregistry
  - Kaminsky's Registry Server
- Web Services uses XML-encoded SOAP messages over HTTP over TCP/IP
- Java RMI uses binary-encoded JRMP (Java Remote Method Protocol) messages directly over TCP/IP
- SOAP is platform-independent; JRMP is Java-specific
- SOAP messages are typically much longer than JRMP messages

JavaScript Object Notation (JSON)

An Internet standard: RFC 4627
Object serialization format using JavaScript syntax
- Textual
- Language-neutral
Typically less verbose than XML-based SOAP -- shorter messages, quicker parsing

Example of a Person object from http://en.wikipedia.org/wiki/Json:

{
    "firstName": "John",
    "lastName": "Smith",
    "age": 25,
    "address": {
        "streetAddress": "21 2nd Street",
        "city": "New York",
        "state": "NY",
        "postalCode": "10021"
    },
    "phoneNumber": [
        {
            "type": "home",
            "number": "212 555-1234"
        },
        {
            "type": "fax",
            "number": "646 555-4567"
        }
    ]
}

JavaScript Object Notation Remote Procedure Call (JSON-RPC)
- A standard for encoding remote procedure calls using JSON
  - Not remote method calls
- Format of a JSON-RPC remote procedure call message:
  {
  "method": "procedure name",
  "params": [ parameter objects ],
  "id": unique id
  }
- Format of a JSON-RPC remote procedure reply message:
  {
  "result": return value,
  "error": error code or null if no error,
  "id": unique id from procedure call message
  }
Simple Object Access Protocol Junior (SOAPjr)
- A combination of SOAP for remote method calls on objects . . .
- Plus JSON (rather than XML) for object encoding
- Not very active, the soapjr.org web site hasn't been updated since 2009
Representational State Transfer (REST)
- REST is not a distributed object system
- REST is a distributed system architectural style, namely the architecture of the World Wide Web
  - Client-server
  - Stateless (no client session state stored on server)
  - Cacheable responses
  - Layered system (intermediate servers allowed)
  - Code on demand (scripts, applets -- optional)
  - Uniform interface between clients and servers
    - HTTP protocol only
    - HTTP methods only (GET, PUT, POST, DELETE)
    - Resources identified with URIs
    - Self-descriptive messages (metadata, MIME types)
    - Hypermedia as the engine of application state (HATEOAS)
      - All resources represented as hypermedia with hyperlinks
      - All actions on resources identified by and performed with hyperlinks
- A web service that follows the REST style is called a "RESTful" web service

Distributed Systems 4005-730-01 Spring Quarter 2013

Course Page

Alan Kaminsky • Department of Computer Science • Rochester Institute of Technology • 4486 + 2220 = 6706

Home Page

Copyright © 2012 Alan Kaminsky. All rights reserved. Last updated 06-Dec-2012. Please send comments to ark@cs.rit.edu.

4005-730 Distributed Systems Lecture Notes -- Module 2. Distributed Object Systems