static CMPIStatus mbModifyInstance(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const CMPIInstance *ci,const char ** properties) {
DDD(cout<<"--- mbSetInstance()"<<endl);
mb=CM_BROKER;
CMPIFlags flgs=ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props=getList(properties);
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CIMInstance cmi(*CM_Instance(ci));
cmi.setPath(*CM_ObjectPath(cop));
CM_CIMOM(mb)->modifyInstance(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
cmi,
CM_IncludeQualifiers(flgs),
props);
CMReturn(CMPI_RC_OK);
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbSetInstance - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
CMReturnWithString((CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
}
CMReturnWithChars(mb,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-2");
}
CIMClass* mbGetClass(const CMPIBroker *mb, const CIMObjectPath &cop) {
DDD(cout<<"--- mbGetClass()"<<endl);
mb=CM_BROKER;
CMPI_Broker *xBroker=(CMPI_Broker*)mb;
String clsId=cop.getNameSpace().getString()+":"+cop.getClassName().getString();
CIMClass *ccp;
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
if (xBroker->clsCache) {
if (xBroker->clsCache->lookup(clsId,ccp)) return ccp;
}
else xBroker->clsCache=new ClassCache();
try {
CIMClass cc=CM_CIMOM(mb)->getClass(
OperationContext(),
cop.getNameSpace(),
cop.getClassName(),
(bool)0,
(bool)1,
(bool)0,
CIMPropertyList());
ccp=new CIMClass(cc);
xBroker->clsCache->insert(clsId,ccp);
return ccp;
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbGetClass - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
}
return NULL;
}
static CMPIEnumeration* mbReferenceNames(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char *resultClass, const char *role,
CMPIStatus *rc) {
DDD(cout<<"--- mbReferencesNames()"<<endl);
mb=CM_BROKER;
CIMObjectPath qop(String::EMPTY,CIMNamespaceName(),
CM_ObjectPath(cop)->getClassName(),
CM_ObjectPath(cop)->getKeyBindings());
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
Array<CIMObjectPath> const &en=CM_CIMOM(mb)->referenceNames(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
qop,
resultClass ? CIMName(resultClass) : CIMName(),
role ? String(role) : String::EMPTY);
if (rc) CMSetStatus(rc,CMPI_RC_OK);
CMPI_Object *obj =
new CMPI_Object(new CMPI_OpEnumeration(new Array<CIMObjectPath>(en)));
return (CMPI_OpEnumeration *)obj->getHdl();
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbReferencesNames - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-11");
return NULL;
}
static CMPIEnumeration* mbEnumInstances(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char **properties, CMPIStatus *rc) {
DDD(cout<<"--- mbEnumInstances()"<<endl);
mb=CM_BROKER;
CMPIFlags flgs=ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props=getList(properties);
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
Array<CIMInstance> const &en=CM_CIMOM(mb)->enumerateInstances(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
CM_ObjectPath(cop)->getClassName(),
CM_DeepInheritance(flgs),
CM_LocalOnly(flgs),
CM_IncludeQualifiers(flgs),
CM_ClassOrigin(flgs),
props);
if (rc) CMSetStatus(rc,CMPI_RC_OK);
CMPI_Object *obj =
new CMPI_Object(new CMPI_InstEnumeration(new Array<CIMInstance>(en)));
return (CMPI_InstEnumeration*)obj->getHdl();
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbEnumInstances - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
return NULL;
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-5");
return NULL;
}
static CMPIData mbGetProperty(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char *name, CMPIStatus *rc) {
DDD(cout<<"--- mbGetProperty()"<<endl);
mb=CM_BROKER;
CMPIData data={0,CMPI_nullValue,{0}};
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CIMValue v=CM_CIMOM(mb)->getProperty(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
*CM_ObjectPath(cop),
String(name));
CIMType vType=v.getType();
CMPIType t=type2CMPIType(vType,v.isArray());
value2CMPIData(v,t,&data);
if (rc) CMSetStatus(rc,CMPI_RC_OK);
return data;
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbGetProperty - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatus(rc,(CMPIrc)e.getCode());
}
if (rc) CMSetStatus(rc,CMPI_RC_ERR_FAILED);
return data;
}
static CMPIInstance* mbGetInstance(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char **properties, CMPIStatus *rc) {
DDD(cout<<"--- mbGetInstance()"<<endl);
mb=CM_BROKER;
CMPIFlags flgs=ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props=getList(properties);
CIMObjectPath qop(String::EMPTY,CIMNamespaceName(),
CM_ObjectPath(cop)->getClassName(),
CM_ObjectPath(cop)->getKeyBindings());
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CIMInstance ci=CM_CIMOM(mb)->getInstance(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
qop, //*CM_ObjectPath(cop),
CM_LocalOnly(flgs),
CM_IncludeQualifiers(flgs),
CM_ClassOrigin(flgs),
props);
ci.setPath(*CM_ObjectPath(cop));
if (rc) CMSetStatus(rc,CMPI_RC_OK);
return (CMPIInstance*)new CMPI_Object(new CIMInstance(ci));
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbGetInstance - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
return NULL;
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-0");
return NULL;
}
static CMPIEnumeration* mbEnumInstanceNames(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, CMPIStatus *rc) {
DDD(cout<<"--- mbEnumInstanceNames()"<<endl);
mb=CM_BROKER;
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
Array<CIMObjectPath> const &en=CM_CIMOM(mb)->enumerateInstanceNames(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
CM_ObjectPath(cop)->getClassName());
if (rc) CMSetStatus(rc,CMPI_RC_OK);
CMPI_Object *obj =
new CMPI_Object(new CMPI_OpEnumeration(new Array<CIMObjectPath>(en)));
return (CMPI_OpEnumeration *)obj->getHdl();
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbEnumInstances - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-6");
return NULL;
}
static CMPIStatus mbDeliverIndication(const CMPIBroker* eMb, const CMPIContext* ctx,
const char *ns, const CMPIInstance* ind) {
DDD(cout<<"--- mbDeliverIndication()"<<endl);
eMb=CM_BROKER;
CMPI_Broker *mb=(CMPI_Broker*)eMb;
CMPIProviderManager::indProvRecord *prec;
OperationContext* context=CM_Context(ctx);
if (CMPIProviderManager::provTab.lookup(mb->name,prec)) {
if (prec->enabled) {
try {
context->get(SubscriptionInstanceNamesContainer::NAME);
}
catch (const Exception &) {
Array<CIMObjectPath> subscriptionInstanceNames;
context->insert(SubscriptionInstanceNamesContainer(subscriptionInstanceNames));
}
CIMIndication cimIndication(*CM_Instance(ind));
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
prec->handler->deliver(
*context,
// OperationContext(*CM_Context(ctx)),
cimIndication);
CMReturn(CMPI_RC_OK);
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbSetProperty - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
CMReturn((CMPIrc)e.getCode());
}
}
}
CMReturn(CMPI_RC_ERR_FAILED);
}
static CMPIStatus mbSetProperty(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char *name, const CMPIValue *val,
CMPIType type) {
DDD(cout<<"--- mbSetProperty()"<<endl);
mb=CM_BROKER;
CMPIrc rc;
CIMValue v=value2CIMValue(val,type,&rc);
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CM_CIMOM(mb)->setProperty(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
*CM_ObjectPath(cop),
String(name),
v);
CMReturn(CMPI_RC_OK);
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbSetProperty - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
CMReturnWithString((CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
}
CMReturnWithChars(mb,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-12");
}
/*-------------------------------------------------------------------------*/
int external_send_raw(char* buf)
{
ir_cmd_t cmd;
int ret=1; // default: cmd failed
DDD("SEND CMD '%s'",buf);
if (!strcasecmp(buf,"Startup")) {
// start vdr
standby(0);
ret=0;
}
else {
if (!strcasecmp(buf,"Standby")) {
if (power_state) {
standby(1);
strcpy(cmd.name,"Power");
}
else {
DDD("already in standby. nothing to do.");
ret=0;
}
}
else if (!strcasecmp(buf,"Poweroff")) {
poweroff();
strcpy(cmd.name,"Power");
}
else if (!strcasecmp(buf,"Eject") && !power_state) {
cdeject();
strcpy(cmd.name,"Eject");
ret=0; // works also in standby
}
else {
strcpy(cmd.name,buf);
}
int shifted=0;
kbdx_t * kbdx=find_named_key(cmd.name, &shifted);
if (!kbdx)
return 0;
cmd.kbdx=kbdx;
cmd.source=0;
cmd.cmd=0; // dummy
cmd.device=0;
cmd.shift=shifted;
cmd.flags=0;
cmd.repeat=0;
cmd.timestamp=get_timestamp();
cmd.flags=0;
cmd.state=REEL_IR_STATE_REEL;
put_code(cmd);
if (power_state)
ret=0;
}
return ret;
}
void StreamBase::clear()
{
DDD(StreamBase);
d->bufref_->clear();
d->posg_ = 0;
d->posp_ = 0;
}
void cPartition::DiskFree()
{
FILE *file = NULL;
std::stringstream command;
char *buffer = NULL;
char buffer2[256];
char trash[512]; // for strings that are not needed
/** get information about used space if available */
command << "LANG=\"C\" df -P /dev/sd" << letter_ << number_ << " | grep ^/dev/sd" << letter_ << number_;
file = popen(command.str().c_str(), "r");
command.str("");
if(file)
{
cReadLine readline;
buffer = readline.Read(file);
if(buffer)
{
sscanf(buffer, "%s %llu %llu %s %s %s", trash, &size_, &used_, trash, trash, buffer2);
mountpoint_ = strdup(buffer2);
}
else
{
//size_ = 0;
used_ = -1;
mountpoint_ = NULL;
}
buffer = NULL;
}
pclose(file);
DDD("size_: %llu, used_: %llu", size_, used_);
}
Stream &Stream::operator=(const Stream &other)
{
DDD(Stream);
Stream tmp(other); // re-use copy-constructor
*this = std::move(tmp); // re-use move-assignment
return *this;
}
/*-------------------------------------------------------------------------*/
void standby(int off)
{
power_state = running_vdr();
///power_state: 1=running, 0=standby
DDD("current power_state: %d", power_state);
if (off && power_state) {
//unlink(STANDBYFILE);
power_state=0;
DDD("turning off ReelVDR");
}
if (!off) {
unlink(STANDBYFILE);
power_state=1;
DDD("Waking up ReelVDR");
}
}
Stream::Stream(Stream &&other)noexcept
:Stream()
{
DDD(Stream);
*d->bufref_ = std::move(*(other.d_func()->bufref_));
d->posg_ = other.d_func()->posg_;
d->posp_ = other.d_func()->posp_;
}
Stream::Stream(const Stream &other)
:Stream()
{
DDD(Stream);
*d->bufref_ = *(other.d_func()->bufref_);
d->posg_ = other.d_func()->posg_;
d->posp_ = other.d_func()->posp_;
}
static CMPIStatus mbDetachThread(const CMPIBroker* mb, const CMPIContext* eCtx) {
DDD(cout<<"--- mbDetachThread()"<<endl);
mb=CM_BROKER;
CMPI_Context *neCtx = (CMPI_Context *)eCtx;
delete neCtx->thr;
// Delete also CMPIContext
delete neCtx;
CMReturn(CMPI_RC_OK);
}
Stream &Stream::operator=(Stream &&other)
{
DDD(Stream);
// simplified move-constructor that also protects against move-to-self.
std::swap(*d->bufref_, *(other.d_func()->bufref_));
std::swap(d->posg_, other.d_func()->posg_);
std::swap(d->posp_, other.d_func()->posp_);
return *this;
}
void StreamBase::read(char *data, size_t size)
{
DDD(StreamBase);
if(size > 0)
{
assert(data);
assert(d->posg_ < (this->size() + size));
memcpy(data, &((*d->bufref_)[d->posg_]), size);
d->posg_ += size;
}
}
void StreamBase::write(const char *data, size_t size)
{
DDD(StreamBase);
if(size > 0)
{
assert(data);
size_t tmp = d->bufref_->size();
resize(tmp + size);
memcpy(&((*d->bufref_)[tmp]), data, size);
}
}
static CMPIContext* mbPrepareAttachThread(const CMPIBroker* mb, const CMPIContext* eCtx) {
DDD(cout<<"--- mbPrepareAttachThread()"<<endl);
mb=CM_BROKER;
OperationContext *ctx=(OperationContext*)((CMPI_Context*)eCtx)->ctx;
OperationContext nctx=*ctx;
CMPIContext* neCtx=new CMPI_Context(*(new OperationContext(nctx)));
CMPIString *name;
for (int i=0,s=CMPI_Args_Ftab->getArgCount((CMPIArgs*)eCtx,NULL); i<s; i++) {
CMPIData data=CMPI_Args_Ftab->getArgAt((CMPIArgs*)eCtx,i,&name,NULL);
CMPI_Args_Ftab->addArg((CMPIArgs*)neCtx,CMGetCharPtr(name),&data.value,data.type);
}
return neCtx;
}
static CMPIEnumeration* mbAssociators(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const char *assocClass, const char *resultClass,
const char *role, const char *resultRole, const char **properties, CMPIStatus *rc) {
DDD(cout<<"--- mbAssociators()"<<endl);
mb=CM_BROKER;
CMPIFlags flgs=ctx->ft->getEntry(ctx,CMPIInvocationFlags,NULL).value.uint32;
const CIMPropertyList props=getList(properties);
CIMObjectPath qop(String::EMPTY,CIMNamespaceName(),
CM_ObjectPath(cop)->getClassName(),
CM_ObjectPath(cop)->getKeyBindings());
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
Array<CIMObject> const &en=CM_CIMOM(mb)->associators(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
qop,
assocClass ? CIMName(assocClass) : CIMName(),
resultClass ? CIMName(resultClass) : CIMName(),
role ? String(role) : String::EMPTY,
resultRole ? String(resultRole) : String::EMPTY,
CM_IncludeQualifiers(flgs),
CM_ClassOrigin(flgs),
props);
if (rc) CMSetStatus(rc,CMPI_RC_OK);
CMPI_Object *obj =
new CMPI_Object(new CMPI_ObjEnumeration(new Array<CIMObject>(en)));
return (CMPI_ObjEnumeration *)obj->getHdl();
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbAssociators - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
return NULL;
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-7");
return NULL;
}
static CMPIStatus mbDeleteInstance (const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop) {
DDD(cout<<"--- mbDeleteInstance()"<<endl);
mb=CM_BROKER;
CIMObjectPath qop(String::EMPTY,CIMNamespaceName(),
CM_ObjectPath(cop)->getClassName(),
CM_ObjectPath(cop)->getKeyBindings());
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CM_CIMOM(mb)->deleteInstance(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
qop); //*CM_ObjectPath(cop));
CMReturn(CMPI_RC_OK);
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbDeleteInstance - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
CMReturnWithString((CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
}
CMReturnWithChars(mb,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-3");
}
static CMPIObjectPath* mbCreateInstance(const CMPIBroker *mb, const CMPIContext *ctx,
const CMPIObjectPath *cop, const CMPIInstance *ci, CMPIStatus *rc) {
DDD(cout<<"--- mbCreateInstance()"<<endl);
mb=CM_BROKER;
AutoMutex mtx(((CMPI_Broker*)mb)->mtx);
try {
CIMObjectPath ncop=CM_CIMOM(mb)->createInstance(
OperationContext(*CM_Context(ctx)),
CM_ObjectPath(cop)->getNameSpace(),
*CM_Instance(ci));
if (rc) CMSetStatus(rc,CMPI_RC_OK);
return (CMPIObjectPath*)new CMPI_Object(new CIMObjectPath(ncop));
}
catch (const CIMException &e) {
DDD(cout<<"### exception: mbCreateInstance - code: "<<e.getCode()<<" msg: "<<e.getMessage()<<endl);
if (rc) CMSetStatusWithString(rc,(CMPIrc)e.getCode(),
(CMPIString*)string2CMPIString(e.getMessage()));
return NULL;
}
if (rc) CMSetStatusWithChars(mb,rc,CMPI_RC_ERROR,"Internal error - CMPIBoker.cpp-1");
return NULL;
}
JMPIProvider::OpProviderHolder JMPILocalProviderManager::getProvider(
const String & fileName,
const String & providerName,
const String & interfaceName)
{
JMPIProvider::OpProviderHolder ph;
CTRL_STRINGS strings;
Sint32 ccode;
strings.fileName = &fileName;
strings.providerName = &providerName;
strings.interfaceName = &interfaceName;
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "ProviderManager::getProvider");
try {
ccode = _provider_ctrl( GET_PROVIDER, &strings, &ph );
}
catch (const Exception &e) {
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::getProvider: loading proxy: "
<<e.getMessage()
<<PEGASUS_STD(endl));
PEG_METHOD_EXIT();
throw;
}
catch(...) {
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::getProvider: catch (...) "
<<PEGASUS_STD(endl));
PEG_METHOD_EXIT();
throw;
}
PEG_METHOD_EXIT();
return(ph);
}
int mediaplugin::TestType(const char *dir, const char *file, bool caseSensitive) {
int cnt=0;
string cmd;
if(caseSensitive)
cmd = string("find ") + dir + " -follow -type f -name '" + file + "' 2> /dev/null";
else
cmd = string("find ") + dir + " -follow -type f -iname '" + file + "' 2> /dev/null";
FILE *p = popen(cmd.c_str(), "r");
if (p) {
char *s;
cReadLine r;
while ((s = r.Read(p)) != NULL) {
if(strcmp(s,"")!=0) cnt++;
}
}
DDD("TYPE %s %d", cmd.c_str(), cnt);
fclose(p);
return cnt;
}
void StreamBase::seekp(size_t pos, SeekMode mode)
{
DDD(StreamBase);
if(mode == begin)
{
assert(pos <= size());
d->posp_ = pos;
}
else if(mode == current)
{
assert((d->posp_ + pos) <= size());
d->posp_ += pos;
}
else
{
assert((size() - pos) >= 0);
d->posp_ = size() - pos;
}
}
/* combine adjacent deleted records *for the current extent* of the capped collection
this is O(n^2) but we call it for capped tables where typically n==1 or 2!
(or 3...there will be a little unused sliver at the end of the extent.)
*/
void NamespaceDetails::compact() {
DDD( "NamespaceDetails::compact enter" );
verify( isCapped() );
vector<DiskLoc> drecs;
// Pull out capExtent's DRs from deletedList
DiskLoc i = cappedFirstDeletedInCurExtent();
for (; !i.isNull() && inCapExtent( i ); i = i.drec()->nextDeleted() ) {
DDD( "\t" << i );
drecs.push_back( i );
}
getDur().writingDiskLoc( cappedFirstDeletedInCurExtent() ) = i;
std::sort( drecs.begin(), drecs.end() );
DDD( "\t drecs.size(): " << drecs.size() );
vector<DiskLoc>::const_iterator j = drecs.begin();
verify( j != drecs.end() );
DiskLoc a = *j;
while ( 1 ) {
j++;
if ( j == drecs.end() ) {
DDD( "\t compact adddelrec" );
addDeletedRec(a.drec(), a);
break;
}
DiskLoc b = *j;
while ( a.a() == b.a() && a.getOfs() + a.drec()->lengthWithHeaders() == b.getOfs() ) {
// a & b are adjacent. merge.
getDur().writingInt( a.drec()->lengthWithHeaders() ) += b.drec()->lengthWithHeaders();
j++;
if ( j == drecs.end() ) {
DDD( "\t compact adddelrec2" );
addDeletedRec(a.drec(), a);
return;
}
b = *j;
}
DDD( "\t compact adddelrec3" );
addDeletedRec(a.drec(), a);
a = b;
}
}
Sint32 JMPILocalProviderManager::_provider_ctrl(CTRL code, void *parm, void *ret)
{
static Uint32 quantum;
PEG_METHOD_ENTER(TRC_PROVIDERMANAGER, "_provider_ctrl");
Sint32 ccode = 0;
CTRL_STRINGS *parms = reinterpret_cast<CTRL_STRINGS *>(parm);
switch(code)
{
case GET_PROVIDER:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::GET_PROVIDER");
String providerName = *(parms->providerName);
String moduleFileName = *(parms->fileName);
String interfaceName = *(parms->interfaceName);
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: GET_PROVIDER "
<<providerName
<<PEGASUS_STD(endl));
JMPIProvider::OpProviderHolder* ph =
reinterpret_cast< JMPIProvider::OpProviderHolder* >( ret );
JMPIProviderModule *newModule = NULL;
JMPIProviderModule *module = NULL;
JMPIProvider *newProvider = NULL;
JMPIProvider *provider = NULL;
ProviderVector base;
try
{
{
AutoMutex lock (_providerTableMutex);
if (true == _providers.lookup(providerName, provider))
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Found JMPIProvider "
+ providerName
+ " in JMPIProvider Manager Cache");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: Found "
<<providerName
<<" in JMPIProvider Manager Cache"
<<PEGASUS_STD(endl));
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" setting provider to "
<<PEGASUS_STD(hex)
<<(int)provider
<<PEGASUS_STD(dec)
<<PEGASUS_STD(endl));
ph->SetProvider(provider);
//////////////////////ph->GetProvider().update_idle_timer();
break;
}
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Creating JMPIProvider " + providerName );
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: Creating "
<<providerName
<<PEGASUS_STD(endl));
if (false == _modules.lookup(moduleFileName, module))
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Creating JMPIProvider Module "
+ moduleFileName );
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"Creating module "
<<moduleFileName
<<PEGASUS_STD(endl));
newModule = new JMPIProviderModule(moduleFileName,
interfaceName);
if (0 == newModule)
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"new JMPIProviderModule is NULL!");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" new JMPIProviderModule is NULL!"
<<PEGASUS_STD(endl));
throw NullPointer();
}
module = newModule;
_modules.insert(moduleFileName, module);
}
else
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Using Cached JMPIProvider Module "
+ moduleFileName);
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"Using cached "
<<moduleFileName
<<PEGASUS_STD(endl));
}
}
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Loading/Linking JMPIProvider Module "
+ moduleFileName );
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" Loading/Linking module "
<<moduleFileName
<<PEGASUS_STD(endl));
try
{
base = module->load(moduleFileName);
}
catch(...)
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Exception caught Loading/Linking"
" JMPIProvider Module "
+ moduleFileName );
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"Exception caught Loading/Linking module "
<<moduleFileName
<<PEGASUS_STD(endl));
throw;
}
// create provider module
newProvider = new JMPIProvider(providerName, module, &base);
if (0 == newProvider)
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"new JMPIProvider is NULL!");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"new JMPIProvider is NULL!"
<<PEGASUS_STD(endl));
throw NullPointer();
}
provider = newProvider;
if (0 == (provider->_cimom_handle = new CIMOMHandle()))
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"_cimom_handle is NULL!");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" _cimom_handle is NULL!"
<<PEGASUS_STD(endl));
throw NullPointer();
}
provider->_quantum = 0;
{
AutoMutex lock(provider->_statusMutex);
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"Loading JMPIProvider "
+ provider->_name);
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" Loading "
<<provider->_name
<<PEGASUS_STD(endl));
try
{
provider->initialize(*(provider->_cimom_handle));
}
catch(...)
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Exception caught calling initialize!");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
" Exception caught calling initialize!"
<<PEGASUS_STD(endl));
throw UninitializedObjectException();
}
}
}
catch (...)
{
if (newModule)
{
_modules.remove(moduleFileName);
}
delete newModule;
if (newProvider)
{
delete newProvider->_cimom_handle;
}
delete newProvider;
throw;
}
// provider->update_idle_timer();
_providers.insert(providerName, provider);
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl:"
"setting provider to "
<<PEGASUS_STD(hex)
<<(int)provider
<<PEGASUS_STD(dec)
<<PEGASUS_STD(endl));
ph->SetProvider( provider );
break;
}
case UNLOAD_PROVIDER:
{
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"UNLOAD_PROVIDER"
<<PEGASUS_STD(endl));
break;
}
case LOOKUP_PROVIDER:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::LOOKUP_PROVIDER");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"LOOKUP_PROVIDER "
<<*(parms->providerName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if (true == _providers.lookup(*(parms->providerName),
*(reinterpret_cast<JMPIProvider * *>(ret))))
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Found JMPIProvider in cache: "
+ *(parms->providerName));
////////////////(*(reinterpret_cast<JMPIProvider * *>(ret)))->update_idle_timer();
}
else
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL4,
"Could not find JMPIProvider in cache: "
+ *(parms->providerName));
ccode = -1;
}
break;
}
case LOOKUP_MODULE:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::LOOKUP_MODULE");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"LOOKUP_MODULE "
<<*(parms->fileName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if (false == _modules.lookup(*(parms->fileName),
*(reinterpret_cast<JMPIProviderModule * *>(ret))))
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER, Tracer::LEVEL4,
"Could not find JMPIProvider Module in cache: " +
*(parms->fileName));
ccode = -1;
}
break;
}
case INSERT_PROVIDER:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::INSERT_PROVIDER");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"INSERT_PROVIDER "
<<*(parms->providerName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if (false == _providers.insert(*(parms->providerName),
*reinterpret_cast<JMPIProvider * *>(parm)))
ccode = -1;
break;
}
case INSERT_MODULE:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::INSERT_MODULE");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"INSERT_MODULE "
<<*(parms->fileName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if(false == _modules.insert(*(parms->fileName),
*reinterpret_cast<JMPIProviderModule * *>(parm)))
ccode = -1;
break;
}
case REMOVE_PROVIDER:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::REMOVE_PROVIDER");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"REMOVE_PROVIDER "
<<*(parms->providerName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if (false == _providers.remove(*(parms->providerName)))
ccode = -1;
break;
}
case REMOVE_MODULE:
{
PEG_TRACE_STRING(TRC_PROVIDERMANAGER,
Tracer::LEVEL2,
"_provider_ctrl::REMOVE_MODULE");
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: REMOVE_MODULE "
<<*(parms->fileName)
<<PEGASUS_STD(endl));
AutoMutex lock (_providerTableMutex);
if (false == _modules.remove(*(parms->fileName)))
ccode = -1;
break;
}
case UNLOAD_ALL_PROVIDERS:
{
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"UNLOAD_ALL_PROVIDERS"
<<PEGASUS_STD(endl));
JMPIjvm::destroyJVM();
break;
}
case UNLOAD_IDLE_PROVIDERS:
{
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"UNLOAD_IDLE_PROVIDERS"
<<PEGASUS_STD(endl));
break;
}
case UNLOAD_IDLE_MODULES:
{
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: "
"UNLOAD_IDLE_MODULES"
<<PEGASUS_STD(endl));
break;
}
default:
{
DDD(PEGASUS_STD(cout)
<<"--- JMPILocalProviderManager::_provider_ctrl: unknown! "
<<code
<<PEGASUS_STD(endl));
ccode = -1;
break;
}
}
PEG_METHOD_EXIT();
return(ccode);
}
static CMPIStatus mbAttachThread(const CMPIBroker* mb, const CMPIContext* eCtx) {
DDD(cout<<"--- mbAttachThread()"<<endl);
((CMPI_Context*)eCtx)->thr=new CMPI_ThreadContext(mb,eCtx);
CMReturn(CMPI_RC_OK);
}
