You are viewing an old version of this page. View the current version.
Compare with Current
View Page History
« Previous
Version 12
Next »
Component IDL
#ifndef _ASYNC_IDL_
#define _ASYNC_IDL_
#pragma prefix "acs"
#include <acscommon.idl>
#include <acscomponent.idl>
module examples
{
interface MyCallback: ACS::OffShoot {
void update(in string text);
};
interface Async : ACS::ACSComponent {
oneway void delayAsync(in ACS::uLong delay, in MyCallback cb);
};
interface Async : ACS::ACSComponent {
void delay(in ACS::uLong delay);
};
};
#endif
Component Implementation
C++
#ifndef _ASYNC_IMPL_H
#define _ASYNC_IMPL_H
#include <acscomponentImpl.h>
#include <AsyncS.h>
class AsyncImpl : public virtual acscomponent::ACSComponentImpl, public virtual POA_examples::Async
{
public:
AsyncImpl(const ACE_CString& name, maci::ContainerServices* containerServices);
virtual ~AsyncImpl();
void delayAsync(ACS::uLong delay, acs::examples::MyCallback_ptr cb);
};
#endif
#include <AsyncImpl.h>
#include <ACSErrTypeOK.h>
AsyncImpl::AsyncImpl(const ACE_CString& name, maci::ContainerServices* containerServices) : acscomponent::ACSComponentImpl(name, containerServices) {
}
AsyncImpl::~AsyncImpl() {
}
void AsyncImpl::delayAsync(ACS::uLong delay, acs::examples::MyCallback_ptr cb) {
cb->update("WORKING");
sleep(delay);
cb->update("DONE");
}
/* --------------- [ MACI DLL support functions ] -----------------*/
#include <maciACSComponentDefines.h>
MACI_DLL_SUPPORT_FUNCTIONS(AsyncImpl)
/* ----------------------------------------------------------------*/
Configuration
<e Name="ASYNC_CPP"
Code="AsyncImpl"
Type="IDL:acs/examples/Async:1.0"
Container="bilboContainer"
ImplLang="cpp"
KeepAliveTime="0"
/>
<e Name="ASYNC_CLIENT_CPP"
Code="AsyncClientImpl"
Type="IDL:acs/examples/AsyncClient:1.0"
Container="bilboContainer"
ImplLang="cpp"
KeepAliveTime="0"
/>
Client Implementation
Callback Definition
C++
#ifndef _MY_CB_IMPL_H
#define _MY_CB_IMPL_H
#include <AsyncC.h>
class MyCBImpl : public virtual POA_examples::MyCallback {
public:
MyCBImpl() {
status=std::string("INIT");
}
virtual ~CBuLongImpl() {}
void update(const char* value) {
status = std::string(value);
}
public:
std::string status;
};
#endif
Standalone Client
C++
#include <maciSimpleClient.h>
#include <AsyncC.h>
#include <ACSErrTypeCommon.h>
#include <acsutilTimeStamp.h>
#include <MyCBImpl.h>
using namespace maci;
int main(int argc, char *argv[]) {
SimpleClient client;
examples::Async_var comp;
if (client.init(argc,argv) == 0) {
return -1;
} else {
client.login();
}
try {
comp = client.getComponent<examples::Async>("ASYNC_CPP", 0, true);
} catch(maciErrType::CannotGetComponentExImpl& _ex) {
_ex.log();
return -1;
}
MyCBImpl cb;
examples::MyCallback_var cbObj = cb._this();
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
comp->delayAsync(8, cbObj.in());
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
sleep(5);
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
sleep(5);
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
try {
client.releaseComponent("ASYNC_CPP");
} catch(maciErrType::CannotReleaseComponentExImpl &_ex) {
_ex.log();
return -1;
}
client.logout();
ACE_OS::sleep(3);
return 0;
}
Component Client
C++
#ifndef _ASYNC_CLIENT_IMPL_H
#define _ASYNC_CLIENT_IMPL_H
#include <acscomponentImpl.h>
#include <AsyncS.h>
class AsyncClientImpl : public virtual acscomponent::ACSComponentImpl, public virtual POA_examples::AsyncClient
{
public:
AsyncClientImpl(const ACE_CString& name, maci::ContainerServices* containerServices);
virtual ~AsyncClientImpl();
void delay(ACS::uLong delay);
};
#endif
#include <AsyncClientImpl.h>
#include <ACSErrTypeOK.h>
AsyncClientImpl::AsyncClientImpl(const ACE_CString& name, maci::ContainerServices* containerServices) : acscomponent::ACSComponentImpl(name, containerServices) {
}
AsyncClientImpl::~AsyncClientImpl() {
}
void AsyncClientImpl::delay(ACS::uLong delay) {
examples::Async_var comp = getContainerServices().getComponent<examples::Async>("ASYNC_CPP", 0, true);
MyCBImpl cb;
ACS::OffShoot_var offshoot = getContainerServices().activateOffShoot(&cb);
examples::MyCallback_var cbObj = examples::MyCallback::_narrow(offshoot);
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
comp->delayAsync(delay, cbObj.in());
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
sleep(delay/2+1);
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
sleep(delay/2+1);
ACS_SHORT_LOG((LM_INFO, "%s", cb.status));
getContainerServices().releaseComponent("ASYNC_CPP");
getContainerServices().deactivateOffShoot(&cb)
}
/* --------------- [ MACI DLL support functions ] -----------------*/
#include <maciACSComponentDefines.h>
MACI_DLL_SUPPORT_FUNCTIONS(AsyncClientImpl)
/* ----------------------------------------------------------------*/
Notes
C++
Standalone Client
When working with standalone clients, we need to handle the servant lifecycle of the offshoots/callbacks. There are two approaches:
- Manual activation/deactivation of the CORBA object
- Manual activation with automatic deactivation of the CORBA object through the POA cleanup process