Show the implementation of Remote Procedure
Call.
The Remote
Procedure Call (RPC)
is an inter-process
communication that allows
a computer program to
cause a subroutine
or procedure to
execute in another
address space (commonly
on another computer
on a shared
network) without the
programmer explicitly coding
the details for this
remote interaction. That
is, the programmer
writes essentially the
same code whether
the subroutine is
local to the
executing program, or
remote. When the
software in question
uses
object-oriented principles,
RPC is called
remote invocation or
remote method invocation.
An
RPC is initiated
by the client,
which sends a
request message to
a known remote
server to execute a
specified procedure with
supplied parameters. The
remote server sends
a response to
the
client, and the
application continues its
process. While the
server is processing
the call, the
client is blocked
(it waits until
the server has
finished processing before
resuming execution), unless
the client sends
an asynchronous request
to the server,
such as an
XHTTP call. There
are many variations
and subtleties in
various implementations, resulting
in a variety
of different (incompatible) RPC
protocols.
An
important difference between
remote procedure calls
and local calls
is that remote
calls can fail
because of unpredictable
network problems. Also,
callers generally must
deal with such
failures without knowing
whether the remote
procedure was actually
invoked. Idempotent procedures
(those that have
no additional effects
if called more
than once) are
easily handled, but
enough difficulties remain
that code to
call remote procedures
is often confined
to carefully
written
low-level subsystems.
Comments
Post a Comment