Distrubuted System Dec2008

Mca distributed system notes

UNIT-1

1. {a} What do you mean by Distributed System ? Explain open Distributed system and its benefits . ( Marks 12 )

Ans- Distributed System- A distributed system consists of a collection of autonomous computers, connected through a network and distribution middleware, which enables computers to coordinate their activities and to share the resources of the system, so that users perceive the system as a single, integrated computing facility

Centralised System Characteristics         One component with non-autonomousparts         Component shared by users all the time

        All resources accessible

        Software runs in a single process

        Single Point of control

        Single Point of failure

Distributed System Characteristics Multiple autonomous components Components are not shared by all users

Resources may not be accessible

Software runs in concurrent processes on different processors

Multiple Points of control

Multiple Points of failure

Common Characteristics Resource Sharing Openness

Concurrency

Scalability

 Fault Tolerance

Transparency

Open distributed systems which provides a foundation for a corresponding architecture description language. This semantic model is based on reported architecture models, with a number of refinements to support abstraction and composition. The model is specifically designed to describe open distributed systems independently of implementation details such as communication protocols and middleware systems. The modelling concepts in the semantic model are: object (a model of an entity), event (a unit of interaction between an object and its environment), event relationship (a specification of behaviour defining the relationships amongst a set of events), interface (an abstraction of an object's interaction with its environment) and binding (a context for interaction between objects). The binding concept is particularly important because it can describe any kind of interaction in an open distributed system, ranging from remote procedure calls and multicast to more complex, enterprise interactions. Special attention is given to the problem of composition and abstraction of events and behaviour in the model. This is needed to reflect the reuse, evolution and interworking requirements of open distributed systems. Our approach allows for the effective modelling of asynchrony, concurrency and complex flows of information in open distributed systems

{b} Explain parameter passing mechanism used in RPC ( Marks 8 )

Ans Parameter Passing - The function of the client stub is to take its parameters, pack them into a message, and send them to the server stub. While this sounds straightforward, it is not quite as simple as it at first appears. In this section we will look at some of the issues concerned with parameter passing in RPC systems.

Passing Value Parameters - Packing parameters into a message is called parameter marshaling. As avery simple example, consider a remote procedure, add(i, j), that takes two integer parameters i and j and returns their arithmetic sum as a result. (As a practical matter, one would not normally make such a simple procedure remote due to the overhead, but as an example it will do.) The call to add, is shown in the left-hand portion (in the client process) in Fig. 2-3. The client stub takes its two parameters and puts them in a message as indicated. It also puts the

name or number of the procedure to be called in the message because the server might support several different calls, and it has to be told which one is requiredWhen the message arrives at the server ,the stub examine the message to see which procedure is needed and makes the appropriate call . if the server also supports other remote procedure the server stub might have a switch statement in it to select the procedure to be called ,depending upon the first field of the message the actual call form stub to the server looks much like the original client call , expect that the parameters are variable initialized from the coming

                                             The step involved in doing a remote computation through RPC

When the message arrives at the server ,the stub examine the message to see which procedure is needed and makes the appropriate call . if the server also supports other remote procedure the server stub might have a switch statement in it to select the procedure to be called ,depending upon the first field of the message the actual call form stub to the server looks much like the original client call , expect that the parameters are variable initialized from the coming

2. {a} What is meant by transparency ? Illustrate different types of Transparency. ( Marks 12 )

Ans - Transparency -         Distributed systems should be perceived by users and application programmers as a

whole rather than as a collection of        cooperating components.         Transparency has different dimensions that were identified by ANSA.

        These represent various properties that distributed systems should have.

There are many types of transparency:            Access transparency - Regardless of how resource access and representation has

to be performed on each individual computing entity, the users of a distributed system should always access resources in a single, uniform way.

          Location transparency - Users of a distributed system should not have to be aware of where a resource is physically located.

          Migration transparency - Users should not be aware of whether a resource or computing entity possesses the ability to move to a different physical or logical location.

          Relocation transparency - Should a resource move while in use, this should not be noticeable to the end user.

          Replication transparency - If a resource is replicated among several locations, it should appear to the user as a single resource.

          Concurrent transparency - While multiple users may compete for and share a single resource, this should not be apparent to any of them. 

           Failure transparency - Always try to hide any failure and recovery of computing entities and resources.

           Persistence transparency - Whether a resource lies in volatile or permanent memory should make no difference to the user.

           Security transparency - Negotiation of cryptographically secure access of resources must require a minimum of user intervention, or users will circumvent the security in preference of productivity

The degree to which these properties can or should be achieved may vary widely. Not every system can or should hide everything from its users. For instance, due to the existence of a fixed and finite speed of light there will always be more latency on accessing resources distant from the user. If one expects real-time interaction with the distributed system, this may be very noticeable.

Transparency Description

AccessHide differences in data representation and how a resource is accessed

Location Hide where a resource is located

Migration Hide that a resource may move to another location

RelocationHide that a resource may be moved to another location while in use

Replication Hide that a resource may be shared by several competitive users

Concurrency Hide that a resource may be shared by several competitive users

Failure Hide the failure and recovery of a resource

Persistence Hide whether a (software) resource is in memory or on disk

{b} What is difference between a distributed operating system and a network operating system . ? ( Marks 8 )

Ans- Difference between a distributed operating system and a network operating system are -

A modern operating system functions on and within a specific computer although it may collect, use or deliver data outside of its self. A distributed system utilities computing power from two or more computer systems. A task may be performed within this computer or on another within the group, or may be split such that portions of a smaller task can be performed on different computers. Remote computing uses messages over a network to request tasks to be undertaken. These messages pass the necessary parameters for the task and on completion messages return the results. Its as if the computers email each other with a request and an answer.

The distinction "modern operating system" versus "distributed operating system" makes little sense, though. Distributed operating systems are in many ways more complex and sophisticated.

With high-end computing demands, distributed operating systems continue to be a very active field of research and development; in many ways making these systems more modern than the mainstream operating systems. Those, instead of "modern operating" system, might better be called "desktop operating system," "single machine operating system," or "mainstream operating system."

Finally, it should be noted that almost any current operating system is a mix between a distributed and a single-machine operating system, including some of the features required for remoting.

Unit – 2

3. {a} Explain multithreaded client and multithreaded server . ( Marks 10 )

Ans  Multithreaded server - A multithreaded server is any server that has more than one thread. Because a transport requires its own thread, multithreaded servers also have multiple transports. The number of thread-transport pairs that a server contains defines the number of requests that the server can handle in parallel. You create the first transport within the task directly from the TService Definition instance and clone additional transports from this initial transport.When a multithreaded server starts:

1.          The first thread in the task starts up and creates a TServiceDefinition using TStandardServiceDefinition.

2.          This thread creates the first transport for the first dispatcher, directly or indirectly.

3.          The thread then creates more threads to receive multiple requests. Each thread can only accommodate one transport;multiple threads cannot share transports. You do not have to create multiple MRemoteDispatcher instances; however, as you can share MRemoteDispatcher instances between threads.

Instances that derive from MRemoteDispatcher and threads do not need to follow a pre-set model. MRemoteDispatcher is extremely lightweight, so you can base your model on the weight and semantics of the specific derivation of MRemoteDispatcher that you intend to use.

Some possible implementations of multithreaded servers include:          One instance of an MRemoteDispatcher for each thread-transport pair          One instance of an MRemoteDispatcher for the entire server (where the derivation

provides its own synchronization for multithreaded access)

         A pool of dispatchers

{b} Having only a single light weight process per process is not a good idea . Why ? ( Marks 10 )

Ans   In this scheme, we effectively have only user-level threads, meaning that any blocking system call will block the entire process.

4. {a} What do you mean by logical clocks ? Discuss lampart's approach for clock synchronization. ( Marks 10 )

Ans   logical clocks -        Let’s say we have a logical clock, LCi for each processor. In this case, when ever an event happens, we shall increment LCi.         If a processor, X, sends a message to processor, Y, then processor X will also send LCX, which is that processors logical clock.         When processor Y receives this message, then we do:                           If LCY < (LCX + 1):                               LCY = LCX + 1         In order to update processor Y’s logical clock.

       Lamport Clocks -       Let’s now say that we have a processor ‘A’ and ‘B’. There are a few things we can say:

                    If A precedes (happens before) B, then we can write A –> B                     If A and B are concurrent events, then sadly we can’t say anything about

their ordering.

If A –> B is true, then it must also be true that LCA < LCB. However, this is not the case. Just because LCA < LCB does not mean that A –> B. Therefore, we can say that we cannot infer a casual ordering of processors just by looking at their timestamps.

In a distributed system, it is not possible in practice to synchronize time across entities (typically thought of as processes) within the system; hence, the entities can use the concept of a logical clock based on the events through which they communicate.

If two entities do not exchange any messages, then they probably do not need to share a common clock; events occurring on those entities are termed as concurrent events.

Among the processes on the same local machine we can order the events based on the local clock of the system.

When two entities communicate by message passing, then the send event is said to 'happen before' the receive event, and the logical order can be established among the events.

A distributed system is said to have partial order if we can have a partial order relationship among the events in the system. If 'totality', i.e., causal relationship among all events in the system can be established, then the system is said to have total order.

{b} What is mutual exclusion ? Explain Bull algorithm ( Marks 10 )

Ans  Mutual exclusion - Systems involving multiple processes are often most easily programmed using critical regions. When a process has to read or update certain shared data structures, it first enters a critical region to achieve mutual exclusion and ensure that no other process will use the shared data structures at the same time. In single processor systems, critical regions are protected using semaphores, monitors, and similar constructs. We will now look at a

few examples of how critical regions and mutual exclusion can be implemented in distributed systems.

At this current moment in time, node ‘7’ is the coordinator, because it is the highest numbered node. But then node ‘7’ leaves, so who is now the coordinator? Lets say node ‘4’ decides it wants to be the coordinator, then we have:

Here, node ‘4’ has sent a ELECTION to nodes ‘5’, ‘6’ and ‘7’, this is because none of the nodes know that node ‘7’ has left yet. In this case, node ‘7’ cannot reply, yet, nodes ‘5’, and ‘6’ are still here, so they reply to ‘4’ that they are still here:

Now we have nodes ‘5’ and ‘6’ sending out elections. In this case, node ‘5’ sends an election to node ‘6’ and ‘7’. Whereas node ‘6’ just sends an election to node ‘7’:

Now, since node ‘6’ is still here, then node ‘6’ tells node ‘5’ that it is still here:

Finally, since node ‘7’ has not replied to node ‘6’, this implies that node ‘7’ no longer exists, meaning that node ‘6’ is the new coordinator. So node ‘6’ tells all the other nodes:

Unit – 3

5. {a} What is consistency ? Explain what are the main reasons for considering Weak consistency models. ( Marks 10 )

Ans   Consistency -  In computer science, in a distributed system such as a distributed shared memory system or a distributed data store such as a database, filesystem, web caching or optimistic replication systems, there are a number of possible data consistency models. The system supports a given model if operations on memory follow specific rules. The data consistency model specifies a contract between programmer and system, wherein the system guarantees that if the programmer follows the rules, memory will be consistent and the results of memory operations will be predictable.

High level languages, such as C, C++, and Java, partially maintain the contract by translating memory operations into low-level operations in a way to preserves memory semantics. To hold the contract, compilers may reorder some memory instructions, and library calls such as pthread_mutex_lock(), encapsulate required synchronization.

Verifying sequential consistency is undecidable in general, even for finite-state cache-coherence protocols. Examples include:

         linearizability (also known as strict or atomic consistency)          sequential consistency

         causal consistency

         release consistency

         eventual consistency

         delta consistency

         PRAM consistency (also known as FIFO consistency)

         weak consistency

         vector-field consistency

         fork consistency

         one-copy Serializability

         entry consistency

Weak consistency models come from the need to replicate for performance. However, efficient replication can be done only if we can avoid global synchronizations, which, in turn, can be achieved by loosening consistency constraints.

{b} Explain how the write ahead log in distributed transactions can be used to Recover from failures. ( Marks 10 )

Ans The log contains a record for each read and write operation that took place within the transaction. When a failure occurs, the log can be replayed to the last recorded operation. Replaying the log is effectively the opposite from rolling back, which happens when the transaction needed to be aborted.

6. Write short notes on the following : ( 5 each )

{a} Secure socket layer

{b} Cryptography

{c} Object replication

{d} Replication in DNS

{a} Secure socket layer - The Secure Sockets Layer (SSL) is a commonly-used protocol for managing the security of a message transmission on the Internet. SSL has recently been succeeded by Transport Layer Security (TLS), which is based on SSL. SSL uses a program layer located between the Internet's Hypertext Transfer Protocol (HTTP) and Transport Control Protocol (TCP) layers. SSL is included as part of both the Microsoft and Netscape browsers and most Web server products. Developed by Netscape, SSL also gained the support of Microsoft and other Internet client/server developers as well and became the de facto standard until evolving into Transport Layer Security. The "sockets" part of the term refers to the sockets method of passing data back and forth between a client and a server program in a network or between program layers in the same computer. SSL uses the public-and-private key encryption system from RSA, which also includes the use of a digital certificate.

TLS and SSL are an integral part of most Web browsers (clients) and Web servers. If a Web site is on a server that supports SSL, SSL can be enabled and specific Web pages can be identified as requiring SSL access. Any Web server can be enabled by using Netscape's SSLRef program library which can be downloaded for noncommercial use or licensed for commercial use. TLS and SSL are not interoperable. However, a message sent with TLS can be handled by a client that handles SSL but not TLS

{b} Cryptography - Fundamental to security in distributed systems is the use of cryptographic techniques. The basic idea of applying these techniques is simple. Consider a sender S wanting to transmit message m to a receiver R. To protect the message against security threats, the sender first encrypts it into an unintelligible message m′, and subsequently sends m′ to R. R, in turn, must decrypt the received message into its original form m.Encryption and decryption are accomplished by using cryptographic methods parametrized by keys, as shown in Fig. 8-6. The original form of the message that is sent is called the plain text, shown as P in Fig. 8-6; the encrypted form isTo describe the various security protocols that is used in building security services for distributed system, it is useful to have a notation to relate plaintext ciphertext, and key. Following the common national convention, we will use C=Ek (p) to denote that the

ciphertext C is obtained by encrypting the plaintext P using key K. Likewise=Dx(C) is used to express the decryption of the ciphertext C using key K, resulting in the plaintext P. Returning to our example shown in fig, while transferring a message as ciphertext C, there are three different attacks that we need to protect against, and for which encryption helps. First, an intruder may intercept the message without either the sender or receiver being aware that eavesdropping is happing. Of course, if the transmitted message has bin encrypted in such a way that it cannot be easily decrypted without having the proper key, interception is useless: the intruder will see only unintelligible data. (By the way, the fact alone that a message is being transmitted may sometimes be enough for an intruder to draw conclusions. For example, if during a world crisis the amount of traffic into the White House suddenly drops to zero while the amount of traffic going into a certain mountain in Colorado increases by the same amount, there may be useful information in knowing that.) The second type of attack that needs to be dealt with is that of modifying the message. Modifying plaintext is easy; modifying ciphertext that has been properly encrypted is much more difficult because the intruder will first have to decrypt the message before it can meaningfully modify it. In addition, he will also have to properly encrypt it again or otherwise the receiver may notice that the message has been tampered with. The third type of attack is when an intruder inserts encrypted messages into the communication system, attempting to make R believe these messages came from S. Again, as we shall see later in this chapter, encryption can help protect against such attacks. Note that if an intruder can modify messages, he can also insert messages.intruders and eavesdroppers in communication

{c} Object replication- Object replication constitutes a generalization of the indicated approaches. In E1 a complete or partial copy of a distributed object's state can be placed in each node where the object is used. The state of an object is synchronized (replicated) among nodes. Each invocation of an object method is handled by its replica in the node, where the call originates. Communication with the remote replicas is involved only when required by the replication protocol, for example, when it is necessary to obtain a missing part of an object state.Thus, the distributed communication in E1 is moved inside the distributed object. Hence, efficiency of access to an object is determined by efficiency of the replication strategy. Obviously, there is no single replication strategy, equally effective for all types of objects. Therefore E1 does not impose the use of any specific strategy or a collection of strategies. Instead, E1 provides services and tools to simplify the construction of replicated objects. In effect, for each class of objects the most efficient access algorithm, which takes into account its semantics, can be applied. Such algorithm can be either selected from a set of existing replication strategies, or designed specifically for the given class of objects. Replication can appear not only as a means of efficient access to an object, but also as a redundancy mechanism. For example, by supporting consistent copies of an object in n different nodes, it is possible to tolerate up to n-1 node crashes .Thus, replication utilizes hardware redundancy of the distributed system to provide reliable execution of applications.

{d} Replication in DNS- Replication is a method of database replication which allows data to be stored by a group of computers, and updated by any member of the group. The multi-master replication system is responsible for propagating the data modifications made by each member to the rest of the group, and resolving any conflicts that might arise between concurrent changes made by different members. Multi-master replication can be contrasted with Master-slave_(computers) replication, in which a single member of the group is designated as the "master" for a given piece of data and is the only node allowed to modify that data item. Other members wishing to modify the data item must first contact the master node. Allowing only a single master makes it easier to achieve consistency among the members of the group, but is less flexible than multi-master replication.

Unit – 4

7.{a} Explain any four forms of communication supported by Corba's invocation Model. ( Marks 10 )

Ans Communication -Originally, CORBA had a simple model of communication: a client invokes a method on an object and waits for an answer. This model was thought to be toosimple and soon additional communication facilities were added. In the following, we take a closer look at invocation facilities in CORBA, and also consider its alternatives to these object invocations. As we will see, the extensions to the basic object invocation model are motivated by the need for asynchronous communication. This motivation also led to the alternative message-passing models that

Object Invocation Models -By default, when a client invokes an object, it sends a request to the corresponding object server and blocks until it receives a response. In the absence of failures, these semantics correspond exactly to a normal method invocation when the caller and callee reside in the same address space. However, matters become somewhat more complicated in the presence of failures. In the case of a synchronous invocation, as just described, a client will eventually receive an exception indicating that the invocation did not fully complete. CORBA specifies that in this case, the invocation should follow at-mostonce semantics, implying that the invoked method may have been invoked once, or not at all. Note that it is up to an implementation to provide these semantics. Synchronous invocation is therefore useful when the client expects an answer.If a proper response is returned, CORBA guarantees that the method has been invoked exactly once. However, in those cases where no response is needed, itwould be better for the client to simply invoke the method and continue with itsown execution as soon as possible. This type of invocation is similar to the asynchronous RPCs. In CORBA, this form of asynchronous invocation is called a one-way request. A method can be specified as being one-way only if it is specified to return no results. However, unlike the guaranteed delivery of asynchronous RPCs,one-way requests in CORBA offer only a best-effort delivery service. In other words, no guarantees are given to the caller that the invocation request is delivered to the object’s server.Besides one-way requests, CORBA also supports what is known as a deferred synchronous request. Such a request is, in fact, a combination of a one-way request and letting the server asynchronously send the result back to the client. As soon as the client sends its request to the server, it continues withoutwaiting for any response from the server. In other words, the client can neverknow for sure whether its request is actually delivered to the server

Invocation Model supported by CORBA

{b} What is NFS ? Discuss some general file attributes in NFS. ( Marks 10 )

Ans Network file system -A network file system is any computer file system that supports sharing of files, printers and other resources as persistent storage over a computer network. The first file servers were developed in the 1970s. In 1976 Digital Equipment Corporation created the File Access Listener (FAL), an implementation of the Data Access Protocol as part of DECnet Phase II which became the first widely used network file system. In 1985 Sun Microsystems created the file system called "Network File System" (NFS) which became the first widely used Internet Protocol based network file system. Other notable network file systems are Andrew File System (AFS), Apple Filing Protocol (AFP), NetWare Core Protocol (NCP), and Server Message Block (SMB) which is also known as Common Internet File System (CIFS).

 Some general mandatory file attributes in NFS.

Attribute Description TYPE The type of the file (regular, directory, symbolic link) SIZE The length of the file in bytes CHANGE Indicator for a client to see if and/or when the file has changed FSID Server-unique identifier of the file's file system

 Some general recommended file attributes.

Attribute Description ACL an access control list associated with the file FILEHANDLE The server-provided file handle of this file FILEID A file-system unique identifier for this file FS_LOCATIONS Locations in the network where this file system may be found OWNER The character-string name of the file's owner TIME_ACCESS Time when the file data were last accessed TIME_MODIFY Time when the file data were last modified TIME_CREATE Time when the file was created

Contents :Transparency - Ideally, a network file system should appear to its users to be a conventional, centralized file system. The multiplicity and dispersion of its servers and storage devices should be made invisible. That is, the client interface used by programs should not distinguish between local and remote files. It is up to the network file system to locate the files and to arrange for the transport of the data.

Performance - The most important performance measurement of a network file system is the amount of time needed to satisfy service requests. In conventional systems, this time consists of a disk-access time and a small amount of CPU-processing time. But in a network file system, a remote access has additional overhead due to the distributed structure. This includes the time to deliver the request to a server, the time to deliver the response to the client, and for each direction, a CPU overhead of running the communication protocol software. The performance of a network file system can be viewed as one dimension of its transparency: ideally, it would be comparable to that of a conventional file system.

Concurrent file updates - Concurrency control is a big and important issue nowadays as more than two persons accessing the same files and want to update it. A network file system should allow multiple client processes on multiple machines to access and update the same files. Hence updates to the file from one client should not interfere with access and updates from other clients. Concurrency control or locking may be either built into the file system or be provided by an add-on protocol.

List of network file systems 9P Amazon S3

Andrew File System (AFS), OpenAFS

Apple Filing Protocol (AFP)

Coda

DCE Distributed File System

File Access Listener (FAL)

NetWare Core Protocol (NCP)

Network File System (protocol) (NFS)

Secure File System (SFS) [1]

Self-certifying File System (SFS)

Server Message Block (SMB)

GlusterFS

8. {a} Discuss the designing issues of distributed file system. ( Marks 10 )

Ans  System design issues

Name resolution - In looking up the pathname of a file (e.g. via the namei function in the UNIX kernel), we may choose to evaluate a pathname a component at a time.

For example, for a pathname aaa/bbb/ccc, we would perform a remote lookup of aaa, then another one of bbb, and finally one of ccc). Alternatively, we may pass the rest of the pathname to the remote machine as one lookup request once we find that a component is remote.

The drawback of the latter scheme is (a) the remote server may be asked to walk up the tree by processing .. (parent node) components and reveal more of its file system than it wants and (b) other components cannot be mounted underneath the remote tree on the local system. Because of this, component at a time evaluation is generally favored but it has performance problems (a lot more messages). We may choose to keep a local cache of component resolutions.

{b} Explain an algorithm for migrating an object in DCOM to another Server. ( Marks 10 )

Ans - The main issues that need to be dealt with is migrating the state to the target object server, and having each client rebind to the migrated object. One possible approach is the following. First, a copy of the object is created on thetarget server using the object’s CLSID. Then, the state

is marshaled and transferred to the new server, where the newly created object is instructed to unmarshal that state. The old copy is replaced by an object implementing a forwarding pointer that offers the same interface as the moved object. Each time an invocation request is forwarded, the invoking client will be notifiedthat it should rebind to the object at its new location.

Unit – 5

9. {a} Explain DSM. Explain the principal operations of a page –based DSM system ( Marks 10 )

Ans  Distributed shared memory - A distributed shared memory is a mechanism allowing end-users' processes to access shared data without using inter-process communications. In other words, the goal of a DSM system is to make inter-process communications transparent to end-users. Both hardware and software implementations have been proposed in the literature. From a programming point of view, two approaches have been studied:

Shared virtual memory: This notion is very similar to the well-known concept of paged virtual memory implemented in mono-processor systems. The basic idea is to group all distributed memories together into a single wide address space. Drawbacks: such systems do not allow to take into account the semantics of shared data: the data granularity is arbitrarily fixed to some page size whatever the type and the actual size of the shared data might be. The programmer has no means to provide informations about these data.

Object DSM: in that class of approaches, shared data are objects i.e. variables with access functions. In his applications, the user has only to define which data (objects) are shared. The whole management of the shared objects (creation, access, modification) is handled by the DSM system. In opposite of SVM systems which work at operating system layer, objects DSM systems actually propose a programming model alternative to the classical message-passing.

In any case, implementing a DSM system implies to address problems of data location, data access, sharing and locking of data, data coherence. Such problems are not specific to parallelism but have connections with distributed or replicated databases management systems (transactionnal model), networks (data migrations), uniprocessor operating systems (concurrent programming), distributed systems.

Principal operations of a page –based DSM systemPage-based DSM makes use of the virtual memory capabilities of an operating system. Whenever an application addresses a memory location that is currently not mapped into the current physical memory, a page fault occurs, giving the operating system control. The operating system can then locate the referred page, transfer its content over the network, and map it to physical memory. At that point, the application can continue.

{b} What are the most important scalability problem in JINIR ( Marks 10 )

Ans Coming Soon

10. Write short notes on the following : ( 5 each )

{a} world wide web (WWW)

{b}  JINI

{c} RMI

{d} Fault tolerance

Ans {a} world wide web (WWW) - The World Wide Web (WWW) can be viewed as a huge distributed system consisting of millions of clients and servers for accessing linked documents. Servers maintain collections of documents, while clients provide users an easyto- use interface for presenting and accessing those documents.The Web started as a project at CERN, the European Particle Physics Laboratory in Geneva, to let its large and geographically dispersed group of researchers provide access to shared documents using a simple hypertext system. A document could be anything that could be displayed on a user’s computer terminal, such as personal notes, reports, figures, blueprints, drawings, and so on. By linking documentsto each other, it became easy to integrate documents from different projects into a new document without the necessity for centralized changes. The only thing needed was to construct a document providing links to other relevant The Web gradually grew worldwide encompassing sites other than highenergy physics, but popularity really increased when graphical user

interfacesbecame available, notably Mosaic (Vetter et al., 1994). Mosaic provided an easy-to-use interface to present and access documents by merely clicking the mouse. A document was fetched from a server, transferred to a client, and presented on the screen. To a user, there was conceptually no difference between a document stored locally or in another part of the world. In this sense, distributionwas transparent.

Overview of WWW - The WWW is essentially a huge client-server system with millions of servers distributed worldwide. Each server maintains a collection of documents; each document is stored as a file (although documents can also be generated on request). A server accepts requests for fetching a document and transfers it to the client. In addition, it can also accept requests for storing new documents.The simplest way to refer to a document is by means of a reference called a Uniform Resource Locator (URL). A URL is comparable to an IOR in CORBA and a contact address in Globe. It specifies where a document is located, often by embedding the DNS name of its associated server along with a file name by which the server can look up the document in its local file system. Furthermore, a URL specifies the application-level protocol for transferring the document acrossthe network. There are different protocols available, as we explain below.

A client interacts with web server thought a special application known as a browser. A browser is responsible for properly dispelling a document.Also,a browser accept input from a user mostly by letting the user select a reference to another document, which it then subsequently fetches and displays. This leads to the overall organization

                                                      The overall organization of  the web

The Web has evolved considerably since its introduction some 10 years ago. By now, there is a wealth of methods and tools to produce information that can be processed by Web clients and Web Server. In the following text, we will go into detail on how the Web act as a distributed system.However,we skip most of the method and tools tactually construct Web document, as they often have no direct relationship to the distributed nature of the Web.A good and thorough introduction on how to build Web-based application can be found in (Deitel and Deitel,2000).

{b}  JINI- Jini is a distributed system that consists of a mixture of different but related elements. It is strongly related to the Java programming language, although many of its principles can be

implemented equally well in other languages. An important part of the system is formed by a coordination model for generative communication.We first discuss this model before giving the overall architecture of a typical Jini system.

                                                           The genral organization of java space in JINI

Architecture -JavaSpaces form only part of a Jini system. Like TIB/Rendezvous, Jini is aimed at providing a small, useful set of facilities and services that will allow the construction of distributed applications. A distributed application using Jini is often described as a loose federation of devices, processes, and services. All communication in current Jini systems is based on Java RMI.

{c} RMI - RMI Usage Location transparency Language integration - using the same syntax for local and remote objects and don't both

about (de)serialising arguments

Protocol independency

use At-most-once invocation semantics

Remote objects can accepts remote method invocations. Must take care of system failures, therefore remote invocation exception must be implemented.

Remote interface descripes methods of a remote object. Remote reference module (these references makes an ID by IP, socket, creation timestamp, object number)

Mapping references between local and remote objects. Create a reference 1.time a remote object is called.

Create a proxy 1.time a remote object reference is received.

Different roles for objects in middleware: Proxy, Dispatcher and Skeleton

Proxy (client) It is first created and exists as long there is a reference to the remote object. the Remote object module take care of thi

Dispatcher (server): selects a method from the skeleton.

Skeleton (server)

1. Unmashalls the arguments from request

2. Invokes a remote object method

3. Mashalls the result into a reply

Communication Module

Binder is a service at the server which contain a index of all the name of remote objects available at the server. If the server want's to make a remote object available, it have to register it in the binder by the name of the remote object

Java RMI - Java RMI is almost location transparent The invoker knows it is a remote method invocation because it can throw a

RemoteException. The implementation of the remote object knows it is remote because

1.           It extends Remote

2.           Implements (an extension) of a remote interface

3.           Trows a RemoteException of the interfaces methods

{d} Fault tolerance - Fault tolerance is subject to much research in computer science. In this section, we start with presenting the basic concepts related to processing failures, followed by a discussion of failure models. The key technique for handling failures is redundancy, which is also discussed. For more general information on fault tolerance in distributed systems, see, for example (Jalote, 1994).

Basic Concepts - To understand the role of fault tolerance in distributed systems we first need to take a closer look at what it actually means for a distributed system to tolerate faults. Being fault

tolerant is strongly related to what are called dependable systems. Dependability is a term that covers a number of useful requirements for distributed systems including the following (Kopetz and Verissimo, 1993): 1. Availability 2. Reliability 3. Safety 4. Maintainability

Availability is defined as the property that a system is ready to be used immediately. In general, it refers to the probability that the system is operating correctly at any given moment and is available to perform its functions on behalf of its users. In other words, a highly available system is one that will most likely be working at a given instant in time. Reliability refers to the property that a system can run continuously without failure. In contrast to availability, reliability is defined in terms of a time interval instead of an instant in time. A highly reliable system is one that will most likely continue to work without interruption during a relatively long period of time. This is a subtle but important difference when compared to availability. If a system goes down for one millisecond every hour, it has an availability of over 99.9999 percent, but is still highly unreliable. Similarly, a system that never crashes but isshut down for two weeks every August has high reliability but only 96 percent availability. The two are not the same. Safety refers to the situation that when a system temporarily fails to operate correctly, nothing catastrophic happens. For example, many process control systems, such as those used for controlling nuclear power plants or sending people into space, are required to provide a high degree of safety. If such control systems temporarily fail for only a very brief moment, the effects could be disastrous. Many examples from the past (and probably many more yet to come) show how hard it is to build safe systems. Finally, maintainability refers to how easy a failed system can be repaired. A highly maintainable system may also show a high degree of availability, especially if failures can be detected and repaired automatically. However, as we shall see later in this chapter, automatically recovering from failures is easier said than done