The Connection Service is the framework-specific mechanism by which instantiated components establish communication links with one another via their typed ports. Only those ports which have the same PortInfo description will be able to participate in a connection. A component can use the Connection Service to connect its own ports to another component. It can also connect two other components for which it has ComponentIDs. The Connection Service can also be used to "export" ports of components for which a ComponentID is known, that is, component A can provide Provides Ports of component B as if they belonged to A - to other components the Provides Port will appear to belong to A, not to B. Finally, if a component does not with to provide one of its ports to the entire world, it can provide it to other components specifically on a "need to know" basis.

By providing an external mechanism for connecting ports, the port types and descriptions themselves can remain free of any connection semantics. As ports are passive participants in the act of connection, we must expose some of their internal structure to the Connection Service, hence the use of ComponentIDs throughout. The relationship of ports to the CCAServices object is what allows us to make this Port-Independent Connection Service available.

• ConnectionService
  

  	value CCAConnectionService : CCAPort {
  
  	  void connect(in ComponentID idUser, in String usesportname,
  		       in ComponentID idProv, in String provportname)
  	       raises (ConnectionException);
  
  	  void disconnect(in ComponentID idUser, in String usesportname,
  			  in ComponentID idProv, in String provportname,
  			  in double timeout)
  	       raises (DisonnectionException);
  
  	  void exportAs(in ComponentID idSub, in String portname,
  			in String myPortname);
  	       raises (ExportAsException);
  
  	  void provideTo(in ComponentID idSub, in String usesPortname,
  			 in Port port);
  	       raises (ProvideToException);
  	}
  	  

• ConnectionService
  

  	  class CCAConnectionService : CCAPort {
  
  	    public:
  
  	    virtual void connect(const ComponentID *idUser, char *usesportname,
  				 const ComponentID *idProv, char *provportname)
  		    throw (ConnectionException) = 0;
  
  	    virtual void disconnect(const ComponentID *idUser, char *usesportname,
  				    const ComponentID *idProv, char *provportname,
  				    const double timeout)
  		    throw (DisconnectionException) = 0;
  
  	    virtual void exportAs(const ComponentID *idSub, char *portname, char *newportname)
  		    throw (ExportAsException) = 0;
  
  	    virtual void provideTo(const ComponentID *idSub, char *usesportname, CCAPort port)
  		    throw (ProvideToException) = 0;
  
  	  }
  
  
  	

• ConnectionService
  

        interface CCAConnectionService extends CCAPort {
  
  	public:
  
  	public void connect(ComponentID idUser, String usesportname,
  			    ComponentID idProv, String provportname)
  	       throws ConnectionException;
  
  	public void disconnect(ComponentID idUser, String usesportname,
  			       ComponentID idProv, String provportname,
  			       double timeout)
  	       throws DisconnectionException;
  
  	public void exportAs(ComponentID idSub, String portname, String newportname)
  	       throws ExportAsException;
  
  	public void provideTo(ComponentID idSub, String usesportname, CCAPort port)
  	       throws ProvideToException;
  
        }
  	

• ConnectionService
  

  • void connect(in ComponentID idUser, in String usesPortname,
                 in ComponentID idProv, in String provPortname)
         raises ConnectionException; [1]
    

    • Parameters
    • idUser: The ComponentID of the component with the Uses Port
    • usesPortname: The name of the Uses Port
    • idProv: The ComponentID of the component with the Provides Port
    • provPortname: The name of the Provides Port
    • Semantics
    • The connect() function is used to connect two component together via their ports. If no exception is thrown then the connection is assumed to have succeeded.
    • If the port types do not match up, or one of the Components rejects the connection, or some other physical calamity occurs, then a ConnectionException is thrown.
  
  
  

  • void disconnect(in ComponentID idUser, in String usesportname,
                    in ComponentID idProv, in String provportname,
                    in double timeout);
         raises DisconnectionException; [2]
    

    • Parameters
    • idUser: The ComponentID of the component with the Uses Port
    • usesPortname: The name of the Uses Port
    • idProv: The ComponentID of the component with the Provides Port
    • provPortname: The name of the Provides Port
    • timeout: The number of seconds to wait before forcibly disconecting
    • Semantics
    • The disconnect() function attempts to disconnect an existing connection. A timer is set locally to the Component "using" the connection in question. If the Component has not done a disconect voluntarily by the time the timer runs out, the Component using the connection is interrupted and forced to close down the connection immediately. If the connection doesn't exist or the connection is no longer in use by the Using component, the disconnect will succeed.
    • If some physical calamity occurs, then a DisconnectionException is thrown.
  
  
  

  • void exportAs(in ComponentID idSub, in String portname, in String myPortname);
         raises ExportAsException; [3]
    

    • Parameters
    • idSub: The ComponentID of a component with a Port you would like to export
    • portname: The name of the port from that ComponentID to be exported
    • myPortname: The name of the Port as it will appear in the exporting Component's list of Ports
    • Semantics
    • Any component for which a ComponentID is known can have its ports exported. If component A has the ComponentID of component idSub but doesn't want to reveal component idSub to the outside world, it can opt to take connections on behalf of component idSub, thus exporting the functionality of idSub through A. The Port will then appear to users of component A as a Port with the name of myPortname.
    • If some physical calamity occurs, then an ExportAsException is thrown.
  
  
  

  • void provideTo(in ComponentID idSub, in String usesPortname, in Port providesPort);
         raises ProvidesToException; [4]
    

    • Parameters
    • idSub: The ComponentID of the component to Provide a Port to
    • usesPortname: The name of the Uses Port of idSub to provide to
    • providesPort: The Uses Port to Provide to idSub
    • Semantics
    • The provideTo function is the way to directly connect a private component Provides Ports to a subcomponent for which a ComponentID is known. The way this differs from the connect() function is that the Provides Port given to the provideTo function need not have been registered in advance. If a component has a Provides Port which it wishes to only make usable by a very limited set of users, it can not register it and use provideTo exclusively to serve the functionality of this port.
    • If some physical calamity occurs, then a ProvidesToException is thrown.

• This is the baseline example of the connection service. A Component will instantiate two other Components and connect them via their ports. After waiting for 30 seconds, the main component will then give the "using" component 5 seconds to disconnect.

  
  // Inside the "main" Component
  CCAServices myS;
  CCACreationService myCreate;
  CCAConnectionService myConnect;
  
  Env creationEnv = new Env();
  creationEnv.put("userData","ninetynineluftballoons"); // There's more to this, of course!
  
  // get a creation service
  myCreate=myS.getPort("CCACreationService");
  
  // create the first component
  ComponentID cid1 = myCreate.createInstance(component1URL,creationEnv);
  
  creationEnv.put("userData","seventysixtrombones"); // There's more to this, of course!
  
  // create the second component
  ComponentID cid2 = myCreate.createInstance(component2URL,creationEnv);
  
  //get a connection service
  myConnect = CCAServices.getPort("CCAConnectionService");
  
  // now connect
  myConnect.connect(cid1, "someUsesPort", cid2, "someProvidesPort");
  
  // At this point Component 1 can use Component 2!!
  
  // let them go at it for 30 seconds
  sleep(30);
  
  // Now disconnect them, giving them a 5 second grace period.
  myConnect.disconnect(cid1, "someUsesPort", cid2, "someProvidesPort", 5.00);
  
  // If after 5 seconds they haven't disconnected then they get disconnected
  // rudely.  At this point we know the disconnect was finished and can continue
  // along.