cs603 distributed object systems n.
Download
Skip this Video
Loading SlideShow in 5 Seconds..
CS603 Distributed Object Systems PowerPoint Presentation
Download Presentation
CS603 Distributed Object Systems

Loading in 2 Seconds...

play fullscreen
1 / 41

CS603 Distributed Object Systems - PowerPoint PPT Presentation


  • 113 Views
  • Uploaded on

CS603 Distributed Object Systems. March 27, 2002. Distributed Object Systems. What are they? CORBA DCOM Java/RMI But what does it mean? RPC for the object crowd With all the tradeoffs/choices/distinctions of RPC systems. Distributed Objects as RPC++. Interface Description Language

loader
I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
capcha
Download Presentation

PowerPoint Slideshow about 'CS603 Distributed Object Systems' - sanam


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.


- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript
distributed object systems
Distributed Object Systems
  • What are they?
    • CORBA
    • DCOM
    • Java/RMI
  • But what does it mean?
    • RPC for the object crowd
    • With all the tradeoffs/choices/distinctions of RPC systems
distributed objects as rpc
Distributed Objects as RPC++
  • Interface Description Language
    • Defines external view of objects
  • Compilers / Precompilers
    • Language extensions
  • Run Time System
    • Directory Services
    • Data Conversion
    • Security / Authentication
distributed object system distinctions
Distributed Object System:Distinctions
  • Single language vs. multilingual
    • Cross-lingual?
  • Platform independence
    • True cross-platform communication?
  • “Extras”
    • Real-time features
    • Fault tolerance
    • Transaction support
the big three
The Big Three
  • CORBA – DCE on steroids
    • Cross-lingual (primarily C++, Java)
    • Cross-platform
    • Many features
  • DCOM – Microsoft’s answer
    • Some cross-lingual support (within Microsoft world)
    • Windows only
    • Built on DCE RPC and COM
  • Java RMI
    • Single language, tightly integrated
corba background
CORBA: Background
  • Object Management Group
    • Corporate-sponsored standards body
    • Members develop and vote on standards
    • Current specs include UML, CORBA
  • Started April 1989
  • Working groups for extensible specifications
    • RealTime CORBA
    • Fault-Tolerant CORBA
    • Embedded CORBA
    • Many more…
corba basics thanks to doug schmidt andrew tannenbaum and omg for figures
CORBA: Basics(Thanks to Doug Schmidt, Andrew Tannenbaum, and OMG for figures)
  • Object Request Broker
  • Object Services
    • Naming, “Trading” (property-based location), security, etc.
  • Common Facilities
    • General interfaces, e.g., OpenDoc
    • Domain interfaces: Standards
    • Application interfaces: IDL specifications for a particular application
corba idl
CORBA IDL
  • Syntactic description of objects
  • Single Interface Definition Language
    • Compiles to multiple binary interfaces:C, C++, Java, Smalltalk, Ada, COBOL, ?
  • Assign Repository Identifier
    • Register interface in interface repository
  • Generate Proxy
    • Client-side stub
    • Marshals invocation request
    • Unmarshals result
  • Also Dynamic Invocation Interface
    • Invoke object when interface not known until runtime
key orb facilities
Key ORB facilities
  • Manipulate object references
    • Marshal/Unmarshal
    • Comparison
  • Service Discovery
    • By name
    • By property
    • Interface repository and Implementation repository
  • ORB/Proxy interface can be vendor specific
invocation models
Invocation Models
  • Default: Synchronous Semantics
    • Block for response
    • Exception on failure
    • At-most-once semantics
  • One-Way Request
    • No response needed/possible
    • Non-blocking
    • Best effort semantics
  • Deferred Synchronous
    • Caller can continue and later wait for result
naming
Naming
  • Object reference
    • Language independent “pointer”
    • POA: Adaptor to make server-side code accessible to client
message passing models
Message passing models
  • Events
    • No guarantees
    • No persistence
  • Notification
    • Events with filtering
persistent communications
Persistent Communications
  • Callback model
    • Client provides object that is called with result
  • Polling Model
    • Client polls for results
  • Messages Stored by ORB
processes
Processes
  • Client and Server distinct
    • Client processes are simple
    • Server potentially complex
  • Agent processes
    • Interface to external agent system
common services
Common Services
  • Collection service
    • List/queue/etc. objects
      • Iterator, get methods
    • “Class library” for CORBA
  • Query service
    • Construct collections searchable through declarative query language
  • Concurrency control service
    • Locking mechanisms
  • Transaction service
services the full list
Services – The Full List
  • Collection Grouping objects into lists, queue, sets, etc.
  • Query Querying collections of objects in a declarative manner
  • Concurrency Allow concurrent access to shared objects
  • Transaction Flat and nested transactions on method calls over multiple objects
  • Event Asynchronous communication through events
  • Notification Event-based asynchronous communication
  • Externalization Marshaling and unmarshaling of objects
  • Life cycle Creation, deletion, copying, and moving of objects
  • Licensing Attaching a license to an object
  • Naming Systemwide naming of objects
  • Property Associating (attribute, value) pairs with objects
  • Trading Publish and find the services an object has to offer
  • Persistence Persistently storing objects
  • Relationship Expressing relationships between objects
  • Security Secure channels, authorization, and auditing
  • Time Current time within specified error margins
interoperability
Interoperability
  • Multiple ORB vendors
    • Do you have to choose one?
  • General Inter-ORB Protocol
    • Framework – without tranport
    • Internet Inter-ORB Protocol on TCP
  • Message Types:
    • From client: Request, LocateRequest, CancelRequest
    • From server: Reply, LocateReply
    • Both: CloseConnection, MessageError, Fragment
cs603 corba

CS603CORBA

March 29, 2002

corba programming
CORBA Programming
  • Select and install an Object Request Broker
    • More later – examples based on ORBIX, C++
  • Define the interfaces (IDL)
  • Create classes that implement interfaces
  • Write server function
    • Instantiates classes
    • Registers with ORB
  • Run Server
  • Write and Run Client
ticket office idl
Ticket Office:IDL

// IDL – file ticket.idl

typedef float Price;

struct Place {

char row;

unsigned long seat;

};

Interface TicketOffice {

readonly attribute string name

readonly attribute unsigned long numberOfSeats

Price getPrice (in Place chosenPlace);

boolean bookSingleSeat (in Place chosenPlace, in string creditCard);

};

ticket office compile idl
Ticket Office:Compile IDL

% idl –B –S ticket.idl // Produces several files:

  • ticket.hh – C++ headers

#include <CORBA.h>

Typedef CORBA::Float Price;

Struct Place { CORBA::Char row; CORBA::ULong seat; };

Class TicketOffice: public virtual CORBA::Object { public:

Virtual char* name() throw (CORBA::SystemException);

Class TicketOfficeBOAImpl { … };

  • ticketC.C // stubs for clients
  • ticketS.C // skeleton for server
  • TicketOffice_i.h, .C // Outline of implementation
ticketoffice implementation declaration
TicketOffice:Implementation Declaration

class TicketOffice_i : public virtual TicketOfficeBOAImpl {

char* m_name;

Price m-highPrice; Price m-lowPrice;

unsigned char** m_avail = {{1 1 1} {1 1 1} {1 1 1}};

public:

TicketOffice_i (const char * theName, const Price theHighPrice, const Price theLowPrice);

virtual ~TicketOffice_i();

virtual char* name() throw (CORBA::SystemException);

virtual CORBA::ULong numberOfSeats()throw (CORBA::SystemException);

virtual Price getPrice (const Place& chosenPlace)throw (CORBA::SystemException);

virtual CORBA::Boolean bookSingleSeat (const Place& chosenPlace, const char* creditCard) throw (CORBA::SystemException);

};

ticketoffice implementation
#include “ticket_i.h”

TicketOffice_i::TicketOffice_i (const char * theName, const Price theHighPrice, const Price theLowPrice) :m_highPrice(theHighPrice), m_lowPrice (theLowPrice) {

m_name = new char[strlen(theName) + 1];

strcpy(m_name, theName); }

TicketOffice_i::~TicketOffice_i() {

delete[] m_name; }

char* TicketOffice_i::name() throw (CORBA::SystemException) {

return CORBA::string_dup(m_name); }

CORBA::ULong TicketOffice::numberOfSeats() throw (CORBA::SystemException) {

return 9; }

Price TicketOffice::getPrice (const Place& chosenPlace) throw (CORBA::SystemException) {

if (chosePlace.row == 1) return m_lowPrice;

else return m_high_price; }

CORBA::Boolean TicketOffice::bookSingleSeat (const Place& chosenPlace,const char* creditCard)throw (CORBA::SystemException) {

unsigned long rowIndex = chosenPlace.row – ‘A’;

if (m_avail[rowIndex][chosePlace.seat]) {

m_avail[rowIndex][chosePlace.seat] = 0;

return 1; }

else return 0; }

TicketOffice:Implementation
ticketoffice server
TicketOffice:Server

#include “ticket_i.h”

int main() {

TicketOffice_i myTicketOffice(“Loeb”, 15.00, 10.00);

CORBA::Orbix.impl_is_read(“TicketOfficeSrv”);

}

  • Following registers server so it is automatically started (or just run a.out)

% putit TicketOfficeSrv a.out

ticketoffice client
TicketOffice:Client

#include “Ticket.hh”

int main() {

TicketOffice_var toVar;

tovar = TicketOffice::_bind(“:TicketOfficeSrv”);

Place p = {‘B’, 1};

if (toVar->bookSingleSeat(p, “1234 5678”))

cout << “Seat B1 booked at ” << toVar->name() <<“ for $” <<toVar->getPrice(p);

else

cout << “Seat B1 taken”;

}

cs603 corba1

CS603CORBA

April 1, 2002

more on registering a server
More on Registering a Server
  • Registration – generic (not Orbix-specific)

CORBA::ORB_ptr orb = “CORBA::ORB_init(argc, argv, “Orbix”);

CORBA::BOA_ptr boa = orb->BOA_init (argc, argv, “Orbix_BOA);

boa->impl_is_ready(“TicketOfficeSrv”);

  • impl_is_ready defaults to waiting forever
    • impl_is_ready(name, ORBA::ULong timeOut);// return if idle for timeOut
wrapping existing code
Wrapping Existing Code
  • TIE approach
    • Creates object that interfaces CORBA to identically declared existing C++ classes
    • Execute DEF_TIE macros to create/bind
  • Multiple inheritance approach
    • CORBA interface implementation inherits
      • BOAImpl
      • Legacy class
finding operations simple binding
Finding operations:Simple Binding
  • Simple
  • Optionally specify host
  • Can specify additional information: Marker
    • ServermyTicketOffice._marker(“Loeb”);myTicketOffice._bind(“TicketOffice”);
    • Clientto_var p =to::_bind(“Loeb:TicketOffice”, “blitz”);
finding operations naming service
Finding Operations:Naming Service
  • Database of bindings: name X object ref
  • Naming context: Hierarchical structure
  • A name is a sequence
    • typedef sequnce<NameComponent> Name;
    • Struct NameComponent
      • id – real name
      • kind – application-specific information
finding operations naming service1
Finding Operations:Naming Service
  • NamingContext interface
    • Object resolve(in Name n) – get object given nameraises ( NotFound, CannotProceed, InvalidName );
    • Void bind(in Name n, in Object o) … -- bind object to name
    • Void bind_context(in Name n, in NamingContext nc) … – put name in context
  • CosNaming interface
    • Struct Binding { Name binding_name; {nobject, ncontext} binding_type };
    • Typedef sequence<Binding> BindingList;
    • Interface NamingContext {void list (in unsigned long how_many, out BindingList bl, out BindingIterator bi); };
naming use
Naming: Use
  • Create hierarchy of naming contexts
    • E.g., tourism: theatre, hotel, …
  • Bind specific name to context
    • tourism.theatre.loeb
  • Resolution: Create name and resolve
    • name = new CosNaming::Name(3);
    • name->length(3);
    • name[0].id = CORBA::string_dup(“tourism”);
    • name[0].kind = CORBA::string_dup(“”);
    • name[1].id = …
  • LoebTicketOffices = namecontext->resolve(name);
    • Also facilities to iterate over or select from multiple results
more on idl
More on IDL
  • IDL supports inheritance, multiple inheritance
    • Implementations must do the same
    • Can redefine operations at implementation level
  • Can forward reference / recursive types

interface a;

interface b { readonly attribute a a_inst };

interface a { … };

  • #include, #define, etc. supported
object references
Object References
  • Can pass objects
  • Given class foo, get class foo_ptr (C++ pointer)
    • Must manually maintain reference counts
      • foo_ptr p2 = p1; p2 = foo::_duplicate(p1);
      • CORBA::release(p2);
    • Class foo_var: Automatically maintains reference counts
    • Use _ptr for parameters
  • Passing objects: Server understands them
    • Parameters defined in IDL
    • Server must have valid implementation (including parameters) to invoke them
casting
Casting
  • Can assign object reference to object reference of parent class
    • Can’t use _var for target and _ptr for source
  • Can Narrow: Assign object to child
    • child = child_class::_narrow(parent)
dynamic invocation following syntax orbix specific
Dynamic Invocation(following syntax ORBIX-specific)
  • Create an “on-the fly” reference

CORBA::Object_ptr target = // any object

CORBA::Request r(target, “operation”)

r << CORBA::inMode << inparameter << CORBA::outMode << outparameter …;

r.invoke();

  • Can use repository to identify name/parameters to construct request
  • Only way to make deferred synchronous calls
    • r.send_deferred(), r.poll_response(), r.get_response()
    • Also r.send_oneway()
dynamic skeleton interface
Dynamic Skeleton Interface
  • Server equivalent of DII
    • Not required to use DII
  • Intended for gateways
    • Server doesn’t understand calls it can process
    • Trusts client/server to generate legal calls
    • Translates to legacy server protocol
security
Security
  • Policy Objects
    • Specify requirements
      • Secure messaging
      • Authentication / signing
      • Trusted host list
  • Security services
    • Know how to implement policy objects