Please enable JavaScript.

Coggle requires JavaScript to display documents.

Remote Invocation (Remote Method Invocation (Implementation (Diagram 21),…

- - - - Maybe
        
        Procedure call executed once or not at all
        
        Unknown whether remote procedure was called unless the caller receives a result
        
        Suitable for applications in which occasional failed calls are acceptable
      - At-least-once
        
        Remote procedure executed at least once + caller received a response
        
        Procedure call not executed + caller received an exception
        
        Sun RPC
        
        Need to handle duplicate requests: run method again? (needs to be idempotent!) store replies? timeout for how long? how much memory is needed?
        
        Suitable for idempotent operations
      - At-most-once
        
        Procedure call executed exactly once + caller received a response
        
        Procedure call not executed + caller received an exception
        
        Java RMI
        
        Need to handle no acknowledgements: keep state on both sides to know when or not to respond/receive acknowledgements
        
        Suitable for non-idempotent operations
  - - - Remote invocations being more prone to failure due to network and remote machines
      - Latency of remote invocations is significantly higher than that of local invocations
  - - - Redundant acknowledgements
      - needs 2 additional messages for establishing connection
      - Flow control not needed - #arguments and #results are limited
  - - - Messages involved in the protocol
      - Methods, arguments, results
      - Rules for marshalling messages
- - - - Locally: might run out of stack space
      - Remotely: network issues
  - - - Issues with passing by value: security, space/bandwidth over the network
      - Use fine-grained interfaces: less bandwidth, more selective with data that is needed; but might need a lot of calls if a lot of info required (then use course-grained interfaces)
      - Issues with passing by reference: not possible; another machine, different address space; if have distributed file system, this is a shared space and is possible
- - - - Objects: consists of attributes + methods
      - Object references: used to access objects
      - Interfaces: define methods that can be invoked by external objects
      - Actions
        
        Objects performing a particular task on a target object
        
        Can result in
        
        Object state changed/queried
        
        A new object created
        
        Delegation of tasks to other objects
      - Exceptions: thrown when an error occurs. Calling program catches them
      - Garbage collection: process of releasing memory used by objects that are no longer in use
    - - Remote object reference: unique ID used throughout a DS to identify an object. (Diagram 18)
      - Remote interface: Defines methods that can be invoked by external processes. Implemented by remote objects (Diagram 19)
      - Remote objects: an object that can receive remote + local invocations ; and invoke methods in local + remote objects(Diagram 17)
      - Actions in a DS: executing a remote method defined in remote interface or creating a new object in the target process. Actions invoked using RMI (Diagram 20)
      - Garbage collection: achieve through reference counting
        
        Remote object continues to exist as long as there are local/remote object references to the object
        
        Server maintains a list of names that hold remote object references (B.holders)
        
        When client A receives a reference to remote object B, it makes a addRef(B) invocation to the server--> adds A to B.holders
        
        When A's garbage collector notices that no references exist for the proxy of remote object B, it makes a removeRef(B) invocation to the server -> server removes A from B.holders
        
        When B.holders is empty, the server's local garbage collector releases the space
        
        Careful with race conditions!
      - Exceptions: similar to local invocations, but special exceptions related to remote invocations are available
  - - - messageType (command)
      - requestId
      - objectReference
      - methodId
      - arguments
    - - Handling timeouts (request/reply)
      - Discarding duplicate messages
      - Handling lost reply messages (strategy depends on whether the server operations are idempotent (an operation that can be performed repeatedly e.g delete a file b/n two peers)
      - History - if servers have to send replies without re-execution, a history has to be maintained
    - - Strategy to retry request message
      - Mechanism to filter duplicates
      - Strategy for results retransmission
  - - - Communicate messages (requests + replies) between client and server
      - uses 3 fields in message
        
        Message type
        
        Request ID
        
        Remote object reference
      - Implements invocation semantics
      - Queries remote reference module to obtain local reference of object --> passes local reference to dispatcher for the class
    - - Create remote object references
      - Maintain remote object table
        
        Used for translating between local and remote object references
        
        Contains an entry for each
        
        Remote object reference held by the process
        
        Local proxy
        
        Add entries when
        
        A remote object reference is passed for the first time
        
        When a remote object reference is received and an entry is not in the table
    - - Lies between application and (communication+object reference modules)
      - 3 components
        
        Proxy
        
        Local object to the invoking object
        
        1 proxy for each remote object
        
        Marshalls the reference to the target object, own method id and arguments. Forwards them to communication module
        
        Unmarshall results and forward them to the invoking object
        
        Dispatcher
        
        1 dispatcher for each remote object class
        
        Map to an appropriate method in the skeleton based on the method ID
        
        Skeleton
        
        Unmarshall arguments in the request and forwards them to the servant
        
        Marshalls the results from the servant to the client
    - - Define interface
      - 2.Compile interface: generate proxy, dispatcher and skeleton classes
      - Write the server program: implement + compile remote object classes, create + initialize objects, register objects with the binder
      - Write the client programs: implement invoking code, contain proxies for all remote classes. Uses a binder to lookup for remote objects (Diagram 22)
    - - Proxies are precompiled to the program --> do not allow invocation of remote interfaces not known during compilation
      - doOperation method: allows invocation of a generic interface
    - - Servants cannot be created by remote invocation on constructors
      - Servants are created during initialization or methods in remote interface designed for this purpose
      - use factory methods to create servants
    - - Maintains a table that contains mappings from textual names to object references
      - Servers register their remote objects by name with the binder
      - Clients look them up by name
  - - - Implementations of the methods
      - Its state in marshalled form