JavaSpaces ™ Nati Shalom CTO GigaSpaces Technologies

Goals Introduction to JavaSpaces™ technology and it’s functions and usage within the Java Services Framework.

Learning Objectives As a result of this presentation, you will be able to: Understand the Space Concept Know more about Java Services Architecture Learn about JavaSpaces™ simplicity and strength Figure out the position of JavaSpaces™ in the overall Java Architecture

Speaker’s Qualifications Nati Shalom is a C.T.O and Co Founder of GigaSpaces a Software Company that specializes in Performance & Scalability of Distributed application using Distributed Shared Memory & JavaSpaces™. Nati Shalom have a vast experience in distributed computing technologies such as CORBA, JINI, Web Services, J2EE Nati Shalom is active in various technological forums such as GRID consortium, SUN/JINI group, I.JUG Nati Shalom is managing the I.JUG Web Services track. Nati Shalom speaks frequently on those topics in conferences and technical courses

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

What is a space: Write Writing an object into a shared pool memory Read Reading and object from a shared pool memory Take Reading and Deleting an object from a shared pool memory Notify Setting and Receiving notifications of changes made within the shared pool memory Small & Powerful API A Network service for Sharing and Exchanging information between distributed services:

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

What Is JavaSpaces? Distributed Shared Memory A Jini ™ Service Transactionally Secure Astonishingly Simple Based on “tuple-spaces” (see David Gelernter’s Linda system)

JavaSpaces Benefits Boost the performance of the Distributed Applications: Distributed Caching Parallel Processing Batching of remote calls. Provides a generic solution for addressing the scalability and high availability of the distributed applications. Hides the complexity of the distributed world: Anonymity between applications Uncoupled communication Programs can communicate through time or space Vast savings in design and development time

JavaSpaces Concepts High-level communications between Java program SIMPLE: only a few operations to learn EXPRESSIVE: a large number of computing problems can be solved

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

JavaSpaces Programs Processes are decoupled from one another Indirect interaction through one or more spaces

Matching Entries A template is used to match entries in a space The template is simply an entry of the type to be matched Fields of the entry are used for matching Non-assigned fields are wildcards

Entries Entries are collections of typed objects Must implement net.jini.core.entry.Entry Fields can be any Serializable Java ™ object Fields must be public to be matchable Entry needs no-arg constructor

Example Entry This shows a minimal entry: package hello; import net.jini.core.entry.Entry; public class Message implements Entry { public String content; public Message() { } Must include a constructor Entry Filed need to be public Must Implements Entry interface

Accessing a Space Jini is used to locate a space Sun’s implementation identifies spaces by name. GigaSpaces identifies spaces by name, container, persistency Convenience method from GigaSpaces: SpaceFinder.find(jini://*/*/spaceName);

Space Operations Very small number of operations are defined on a space The three fundamental operations are: Write Read Take

Write Operation Writes an entry to a space

Write Operation Instantiate an Entry Set its fields as necessary Write the entry to the space Message msg = new Message(); msg.content = "Hello World"; JavaSpace space = (JavaSpace)SpaceFinder.find( args[0] ); space.write(msg, null, Lease.FOREVER);

Read Operation Reads an entry from a space Copy of object is returned Original remains in space

Read Operation Build a template Read a matching entry from the space Message template = new Message(); Message result = (Message)space.read(template, null, Long.MAX_VALUE);

Take Operation Takes an entry from a space Matched entry is removed from space

Take Operation Build a template Take a matching entry from the space Message template = new Message(); Message result = (Message)space.take(template, null, Long.MAX_VALUE);

Snapshot Operation The snapshot operation is used for performance optimization It generates an image of the Entry. This image usually saves the serialization overhead. Message template = new Message(); Entry snapshot = space.snapshot(template) Message result = (Message)space.read( snapshot, null, Long.MAX_VALUE);

The Notify Operation The space implements the JINI RemoteEvents pattern Clients can register for events on write operation using the notify method. The notify callback should implement a RemoteEventListener

Notify Operation (Cont) Registering for notifications // Register a notification template = space.snapshot(new Message()); EventRegistration reg = space.notify( template, null, //TX SpaceEventListener(), // The listener 60000, // Lease null);// handbag System.out.println("Notification registered. Registration id: " + reg.getID() + “ Sequence number: " + reg.getSequenceNumber());

The Notify Operation (Cont) RMI Event Listener public class SpaceEventListener extends UnicastRemoteObject implements RemoteEventListener { public SpaceEventListener() throws java.rmi.RemoteException{} public void notify(net.jini.core.event.RemoteEvent theEvent) throws net.jini.core.event.UnknownEventException, java.rmi.RemoteException { System.out.println("\nGot event from space:"); System.out.println("Event Source: " + theEvent.getSource()); System.out.println("Event Id: " + theEvent.getID()); } }

Other Space Operations ReadIfExists() Non-blocking read takeIfExists() Non-blocking take

Clustering Models With JavaSpaces Clustered Space A network of cooperating spaces with single, virtual, interface Replication Manages the distribution of work between the cluster spaces Fail-Over Manages the process of transparent re-routing in case of failure during an active session Load Balancing Enables partial or full replication between groups of spaces.

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

The Service Oriented Approach What’s Missing ? Data sharing between services Activities synchronized between services Data collaboration between services Optimal Performance Application ABC Components Becomes… Component Oriented Composite Application ABC Services Service Oriented

Using JavaSpaces™ as a Shared Address Space between services The Space itself is A SERVICE that provides Shared Memory Capabilities. Services allocate space dynamically. Unique Benefits: Performance Distributed Caching Parallel Processing Virtualization Collaboration Synchronization Personalization Session Sharing Single Sign On Composite Application ABC Services Distributed Shared Memory Service Distributed Shared Memory Service

Enterprise Service Bus “In 2002, a new form of infrastructure that combines Web services, messaging, basic transformation and content-based routing came to market. These low-cost, application-server-neutral enterprise service buses (ESBs) are well suited to be the backbones for SOAs and basic ENSs.” Source: “From Enterprise Network to Enterprise Nervous System” Massimo Pezzini, 10–12 March 2003

Why Now? (Cont) Network vs. computer performance Computer speed doubles every 18 months Network speed doubles every 9 months Difference = order of magnitude per 5 years 1986 to 2000 Computers: x 500 Networks: x 340, to 2010 Computers: x 60 Networks: x 4000 Moore’s Law vs. storage improvements vs. optical improvements. Graph from Scientific American (Jan-2001).

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

The JINI Services Architecture

Structure of Jini ™ Technology

Step 1: Registering a Service

Step 2: Finding a Service Client Lookup Service

Step 3: Using a Service

JoinManager & DiscoveryManager Locating services can be done using the utility classes of ``Discovery Management'‘ The JoinManager uses the DiscoveryManager for locating an LUS. It than register the service with each LUS. The JoinManager provides two constructors: No serviceId – This constructor should be used in the first time the service has been registered. With serviceId - This constructor should be used after the service had been assigned atleast once a service id.

Example:Joining A Service with all LUS JoinManager joinMgr = null; try { LookupDiscoveryManager mgr = new LookupDiscoveryManager(LookupDiscovery.ALL_GROUPS, null /* unicast locators */, null /* DiscoveryListener */); joinMgr = new JoinManager(new FileClassifierImpl(), /* service */ null /* attr sets */, this /* ServiceIDListener*/, mgr /* DiscoveryManagement */, new LeaseRenewalManager()); } catch(Exception e) {..}

ServiceDiscoveryManager The class ServiceDiscoveryManager is only available in Jini 1.1. It performs client-side functions similar to that of JoinManager for services, and simplifies the tasks of finding services

ServiceDiscoveryManager Goals The ServiceDiscoveryManager was designed to assist clients with the following tasks: A client may wish to use a service immediately or later A client may want to use multiple services A client will want to find services by their interface, but may also want to apply additional criteria, such as being a ``fast enough'' printer A client may just wish to use a service if it is available at the time of request, but alternatively may want to be informed of new services becoming available and respond to this new availability (for example, a service browser)

The ServiceDiscoveryManger Interface public class ServiceDiscoveryManager { public ServiceDiscoveryManager(DiscoveryManagement discoveryMgr, LeaseRenewalManager leaseMgr) throws IOException; LookupCache createLookupCache(ServiceTemplate tmpl, ServiceItemFilter filter, ServiceDiscoveryListener listener); ServiceItem[] lookup(ServiceTemplate tmpl, int maxMatches, ServiceItemFilter filter); ServiceItem lookup(ServiceTemplate tmpl, ServiceItemFilter filter); ServiceItem lookup(ServiceTemplate tmpl, ServiceItemFilter filter, long wait); ServiceItem[] lookup(ServiceTemplate tmpl, int minMaxMatch, int maxMatches, ServiceItemFilter filter, long wait); void terminate(); }

Finding a Service Immediately try { LookupDiscoveryManager mgr = new LookupDiscoveryManager(LookupDiscovery.ALL_GROUPS, null /* unicast locators */, null /* DiscoveryListener */); clientMgr = new ServiceDiscoveryManager(mgr, new LeaseRenewalManager()); } catch( … ) {.. } Class [] classes = new Class[] {FileClassifier.class}; ServiceTemplate template = new ServiceTemplate(null, classes, null); ServiceItem item = null; // Try to find the service, blocking till timeout if necessary try { item = clientMgr.lookup(template, null, /* no filter */ WAITFOR /* timeout */); } catch(..) {..}

The Details: Programming using Leases, Events, and Transactions

Why Distributed Leasing? Problem: Partial failure in distributed systems can lead to unchecked resource consumption Traditional solution: system administration Error-prone Costly Only happens when it’s too late

Distributed Leasing in Jini™ Protocol for managing resources using a renewable, duration-based model Contract between objects Resources can be shared or private Provides a method of managing resources in an environment where network failures can, and do, occur

What are Leases? Time-based grants of resources or services Loose contracts between grantor and holder Negotiated for a set period of time Can be shared or exclusive

Lease Operations Leases may be: Cancelled (explicit cleanup) Renewed (explicit extension) Allowed to expire (implicit cleanup) Obtained and manipulated by third parties

Distributed Leasing Resources are allocated only as long as continued interest is shown Leasee is responsible to renew lease before expiry The network is self-healing

Distributed Events Extend Java™ event model to work in a distributed network Register interest, receive notification Allow for use of event managers Support various delivery models Push, pull, filter Use the Distributed Leasing protocol

Transaction model in Jini™ Designed for distributed object coordination Light weight, object-oriented Supports two-phase commits Uses Distributed Leasing protocol Implemented in Transaction Manager service

Agenda What Is A Space What Is JavaSpaces™ JavaSpaces™ Benefits Programming with JavaSpaces™ The Service Oriented Architecture (SOA) JINI Service Platform Summary & References

GigaSpaces Free Academic Program GigaSpaces Free Academic Program Is available through the web site.

JavaSpaces™ Resources Visit our GigaSpaces booth.

Thank you for listening