/*
**==============================================================================
**
** Open Management Infrastructure (OMI)
**
** Copyright (c) Microsoft Corporation
**
** Licensed under the Apache License, Version 2.0 (the "License"); you may not
** use this file except in compliance with the License. You may obtain a copy
** of the License at
**
** http://www.apache.org/licenses/LICENSE-2.0
**
** THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
** KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
** WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
** MERCHANTABLITY OR NON-INFRINGEMENT.
**
** See the Apache 2 License for the specific language governing permissions
** and limitations under the License.
**
**==============================================================================
*/
#include "client.h"
#include
#include
#include
#include
#include "thread.h"
#define TRACE printf("TRACE: %s(%u)\n", __FILE__, __LINE__)
#if 0
# define D(X) X
#else
# define D(X) /* empty */
#endif
MI_BEGIN_NAMESPACE
//==============================================================================
//
// Local definitions.
//
//==============================================================================
Uint64 _NextMsgID()
{
static Mutex mutex;
mutex.Lock();
static Uint64 _msgID = 10000;
Uint64 x = _msgID++;
mutex.Unlock();
return x;
}
static char* _StringToStr(const String& str)
{
Uint32 n = str.GetSize();
char* r = new char[n + 1];
if (!r)
return NULL;
for (Uint32 i = 0; i < n; i++)
{
r[i] = char(str[i]);
}
r[n] = '\0';
return r;
}
//==============================================================================
//
// class EnvelopeHandler
//
//==============================================================================
class EnvelopeHandler : public Handler
{
public:
EnvelopeHandler(Handler* handler) : m_handler(handler)
{
}
virtual void HandleConnect()
{
if (m_handler)
m_handler->HandleConnect();
}
virtual void HandleConnectFailed()
{
if (m_handler)
m_handler->HandleConnectFailed();
}
virtual void HandleDisconnect()
{
if (m_handler)
m_handler->HandleDisconnect();
}
virtual void HandleNoOp(Uint64 msgID)
{
if (m_handler)
m_handler->HandleNoOp(msgID);
}
virtual void HandleInstance(Uint64 msgID, const DInstance& instance)
{
if (m_handler)
m_handler->HandleInstance(msgID, instance);
}
virtual void HandleResult(Uint64 msgID, MI_Result result)
{
if (m_handler)
m_handler->HandleResult(msgID, result);
}
private:
Handler* m_handler;
};
//==============================================================================
//
// class NoOpHandler
//
//==============================================================================
class NoOpHandler : public EnvelopeHandler
{
public:
enum State { START, DONE, FAILED };
NoOpHandler(Handler* handler, Uint64 msgID) :
EnvelopeHandler(handler), m_state(START), m_msgID(msgID)
{
}
virtual void HandleNoOp(Uint64 msgID)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleNoOp(msgID);
return;
}
if (m_state != START)
{
m_state = FAILED;
return;
}
m_state = DONE;
}
State m_state;
Uint64 m_msgID;
};
//==============================================================================
//
// class ResultHandler
//
//==============================================================================
class ResultHandler : public EnvelopeHandler
{
public:
enum State { START, DONE, FAILED };
ResultHandler(Handler* handler, Uint64 msgID) :
EnvelopeHandler(handler),
m_state(START),
m_msgID(msgID),
m_result(MI_RESULT_OK)
{
}
virtual void HandleResult(Uint64 msgID, Result result)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleResult(msgID, result);
return;
}
if (m_state != START)
{
m_state = FAILED;
return;
}
m_result = result;
m_state = DONE;
}
State m_state;
Uint64 m_msgID;
Result m_result;
};
//==============================================================================
//
// class InstanceHandler
//
//==============================================================================
class InstanceHandler : public EnvelopeHandler
{
public:
enum State { INSTANCE, RESULT, DONE, FAILED };
InstanceHandler(
Handler* handler,
Uint64 msgID,
DInstance& instance)
:
EnvelopeHandler(handler),
m_state(INSTANCE),
m_msgID(msgID),
m_instance(instance),
m_result(MI_RESULT_OK)
{
}
virtual void HandleInstance(Uint64 msgID, const DInstance& instance)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleInstance(msgID, instance);
return;
}
if (m_state != INSTANCE)
{
m_state = FAILED;
return;
}
m_instance = instance;
m_state = RESULT;
}
virtual void HandleResult(Uint64 msgID, Result result)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleResult(msgID, result);
return;
}
if (m_state != INSTANCE && m_state != RESULT)
{
m_state = FAILED;
return;
}
m_result = result;
m_state = DONE;
}
State m_state;
Uint64 m_msgID;
DInstance& m_instance;
Result m_result;
};
//==============================================================================
//
// class InstancesHandler
//
//==============================================================================
class InstancesHandler : public EnvelopeHandler
{
public:
enum State { INSTANCES, RESULT, DONE, FAILED };
InstancesHandler(
Handler* handler,
Uint64 msgID,
Array& instances)
:
EnvelopeHandler(handler),
m_state(INSTANCES),
m_msgID(msgID),
m_instances(instances),
m_result(MI_RESULT_OK)
{
}
virtual void HandleInstance(Uint64 msgID, const DInstance& instance)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleInstance(msgID, instance);
return;
}
if (m_state != INSTANCES)
{
m_state = FAILED;
return;
}
m_instances.PushBack(instance);
}
virtual void HandleResult(Uint64 msgID, Result result)
{
if (msgID != m_msgID)
{
EnvelopeHandler::HandleResult(msgID, result);
return;
}
if (m_state != INSTANCES)
{
m_state = FAILED;
return;
}
m_result = result;
m_state = DONE;
}
State m_state;
Uint64 m_msgID;
Array& m_instances;
Result m_result;
};
//==============================================================================
//
// class ClientRep
//
//==============================================================================
class ClientRep
{
public:
enum ConnectState
{
CONNECTSTATE_PENDING,
CONNECTSTATE_FAILED,
CONNECTSTATE_CONNECTED,
CONNECTSTATE_DISCONNECTED
};
Protocol* protocol;
Handler* handler;
ConnectState connectState;
static void EventCallback(
Protocol* protocol,
ProtocolEvent event,
void* data);
static MI_Boolean MessageCallback(
Protocol* protocol,
Message* msg,
void* data);
bool NoOpAsync(
Uint64 msgID);
bool GetInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64 msgID);
bool CreateInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64 msgID);
bool ModifyInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64 msgID);
bool DeleteInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64 msgID);
bool EnumerateInstancesAsync(
const String& nameSpace,
const String& className,
bool deepInheritance,
const String& queryLanguage,
const String& queryExpression,
Uint64 msgID);
bool InvokeAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& methodName,
const DInstance& inParameters,
DInstance& outParameters,
Uint64 msgID);
bool AssociatorInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& resultClass,
const String& role,
const String& resultRole,
Uint64& msgID);
bool ReferenceInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& role,
Uint64& msgID);
};
void ClientRep::EventCallback(
Protocol* protocol,
ProtocolEvent event,
void* data)
{
ClientRep* clientRep = (ClientRep*)data;
Handler* handler = clientRep->handler;
D( printf("==== ClientRep::EventCallback()\n"); )
if (event == PROTOCOLEVENT_CONNECT)
{
D( printf("==== EventCallback() PROTOCOLEVENT_CONNECT\n"); )
clientRep->connectState = ClientRep::CONNECTSTATE_CONNECTED;
if (handler)
handler->HandleConnect();
return;
}
if (event == PROTOCOLEVENT_CONNECT_FAILED)
{
D( printf("==== EventCallback() PROTOCOLEVENT_CONNECT_FAILED\n"); )
if (handler)
handler->HandleConnectFailed();
clientRep->connectState = ClientRep::CONNECTSTATE_FAILED;
return;
}
if (event == PROTOCOLEVENT_DISCONNECT)
{
D( printf("==== EventCallback() PROTOCOLEVENT_DISCONNECT\n"); )
if (handler)
handler->HandleDisconnect();
clientRep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
return;
}
}
MI_Boolean ClientRep::MessageCallback(
Protocol* protocol,
Message* msg,
void* data)
{
ClientRep* clientRep = (ClientRep*)data;
Handler* handler = clientRep->handler;
DEBUG_ASSERT(msg != 0);
switch (msg->tag)
{
case NoOpRspTag:
{
D( printf("ClientRep::MessageCallback(): NoOpRspTag\n"); )
NoOpRsp* rsp = (NoOpRsp*)msg;
MI_UNUSED(rsp);
if (handler)
handler->HandleNoOp(rsp->base.msgID);
break;
}
case PostInstanceMsgTag:
{
D( printf("ClientRep::MessageCallback(): PostInstanceMsgTag\n"); )
PostInstanceMsg* rsp = (PostInstanceMsg*)msg;
if (rsp->instance)
{
DInstance di(rsp->instance, DInstance::CLONE);
if (handler)
handler->HandleInstance(rsp->base.msgID, di);
}
break;
}
case SubscribeResTag:
{
D( printf("ClientRep::MessageCallback(): SubscribeResTag\n"); )
SubscribeRes* rsp = (SubscribeRes*)msg;
MI_UNUSED(rsp);
break;
}
case PostResultMsgTag:
{
D( printf("ClientRep::MessageCallback(): PostResultMsgTag\n"); )
PostResultMsg* rsp = (PostResultMsg*)msg;
if (handler)
handler->HandleResult(rsp->base.msgID, rsp->result);
break;
}
default:
{
D( printf("ClientRep::MessageCallback(): default\n"); )
break;
}
}
return MI_TRUE;
}
bool ClientRep::NoOpAsync(
Uint64 msgID)
{
NoOpReq* req = 0;
bool result = true;
// Fail if not connected:
if (!protocol)
{
result = false;
goto done;
}
// Create request message:
{
req = NoOpReq_New(msgID);
if (!req)
{
result = false;
goto done;
}
}
// Send the message:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
NoOpReq_Release(req);
return result;
}
bool ClientRep::GetInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64 msgID)
{
GetInstanceReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = GetInstanceReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instanceName.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstanceNamePtr,
&req->packedInstanceNameSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
GetInstanceReq_Release(req);
return result;
}
bool ClientRep::CreateInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64 msgID)
{
CreateInstanceReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = CreateInstanceReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instance.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstancePtr,
&req->packedInstanceSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
CreateInstanceReq_Release(req);
return result;
}
bool ClientRep::ModifyInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64 msgID)
{
ModifyInstanceReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = ModifyInstanceReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instance.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstancePtr,
&req->packedInstanceSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
ModifyInstanceReq_Release(req);
return result;
}
bool ClientRep::DeleteInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64 msgID)
{
DeleteInstanceReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = DeleteInstanceReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instanceName.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstanceNamePtr,
&req->packedInstanceNameSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
DeleteInstanceReq_Release(req);
return result;
}
bool ClientRep::EnumerateInstancesAsync(
const String& nameSpace,
const String& className,
bool deepInheritance,
const String& queryLanguage,
const String& queryExpression,
Uint64 msgID)
{
EnumerateInstancesReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = EnumerateInstancesReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Populate the fields of the request message:
{
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
req->className = Batch_Zdup(req->base.batch, className.Str());
if (queryLanguage.GetSize())
{
req->queryLanguage =
Batch_Zdup(req->base.batch, queryLanguage.Str());
}
if (queryExpression.GetSize())
{
req->queryExpression =
Batch_Zdup(req->base.batch, queryExpression.Str());
}
req->deepInheritance = deepInheritance;
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
EnumerateInstancesReq_Release(req);
return result;
}
bool ClientRep::InvokeAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& methodName,
const DInstance& inParameters,
DInstance& outParameters,
Uint64 msgID)
{
InvokeReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = InvokeReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Set className:
req->className = Batch_Zdup(req->base.batch,
instanceName.GetClassName().Str());
// Set methodName:
req->function = Batch_Zdup(req->base.batch, methodName.Str());
// Pack instanceName:
if (instanceName.Count())
{
Result r = InstanceToBatch(
instanceName.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstancePtr,
&req->packedInstanceSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Pack inParameters:
{
Result r = InstanceToBatch(
inParameters.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstanceParamsPtr,
&req->packedInstanceParamsSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
InvokeReq_Release(req);
return result;
}
bool ClientRep::AssociatorInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& resultClass,
const String& role,
const String& resultRole,
Uint64& msgID)
{
AssociatorsOfReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = AssociatorsOfReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Set assocClass:
if (assocClass.GetSize())
req->assocClass = Batch_Zdup(req->base.batch, assocClass.Str());
// Set resultClass:
if (resultClass.GetSize())
req->resultClass = Batch_Zdup(req->base.batch,resultClass.Str());
// Set role:
if (role.GetSize())
req->role = Batch_Zdup(req->base.batch, role.Str());
// Set resultRole:
if (resultRole.GetSize())
req->resultRole = Batch_Zdup(req->base.batch, resultRole.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instanceName.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstancePtr,
&req->packedInstanceSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
{
AssociatorsOfReq_Release(req);
}
return result;
}
bool ClientRep::ReferenceInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& role,
Uint64& msgID)
{
ReferencesOfReq* req = 0;
bool result = true;
// Fail if not connected.
if (!protocol)
{
result = false;
goto done;
}
// Create the request message:
{
req = ReferencesOfReq_New(msgID, BinaryProtocolFlag);
if (!req)
{
result = false;
goto done;
}
}
// Set nameSpace:
req->nameSpace = Batch_Zdup(req->base.batch, nameSpace.Str());
// Set assocClass:
if (assocClass.GetSize())
req->assocClass = Batch_Zdup(req->base.batch, assocClass.Str());
// Set role:
if (role.GetSize())
req->role = Batch_Zdup(req->base.batch, role.Str());
// Pack the instance name into the message's batch.
{
Result r = InstanceToBatch(
instanceName.m_self,
NULL,
NULL,
req->base.batch,
&req->packedInstancePtr,
&req->packedInstanceSize);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
// Send the messages:
{
Result r = Protocol_Send(protocol, &req->base);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
}
done:
if (req)
ReferencesOfReq_Release(req);
return result;
}
//==============================================================================
//
// class Client
//
//==============================================================================
Client::Client(Handler* handler)
{
m_rep = new ClientRep;
m_rep->protocol = 0;
m_rep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
m_rep->handler = handler;
}
Client::~Client()
{
Disconnect();
delete m_rep->handler;
delete m_rep;
}
bool Client::ConnectAsync(
const String& locatorIn,
const String& user,
const String& password)
{
Result r;
bool result = true;
String locator = locatorIn;
char* locator_ = NULL;
char* user_ = NULL;
char* password_ = NULL;
// Fail if already connected:
if (m_rep->protocol)
{
result = false;
goto done;
}
// Locator defaults to SOCKETFILE:
if (locator.GetSize() == 0)
{
#ifdef CONFIG_POSIX
locator = GetPath(ID_SOCKETFILE);
#else
locator = MI_T("localhost:7777");
#endif
}
// Convert host to 'char' type:
locator_ = _StringToStr(locator);
if (!locator_)
{
goto done;
}
user_ = _StringToStr(user);
if (!user_)
{
goto done;
}
password_ = _StringToStr(password);
if (!password_)
{
goto done;
}
// Set connection state to pending.
m_rep->connectState = ClientRep::CONNECTSTATE_PENDING;
// Establish connection with server:
{
Protocol* protocol = NULL;
r = Protocol_New_Connector(
&protocol,
NULL,
locator_,
(ProtocolCallback)ClientRep::MessageCallback,
m_rep,
(ProtocolEventCallback)ClientRep::EventCallback,
m_rep,
user_,
password_);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
m_rep->protocol = protocol;
}
done:
if (locator_)
delete [] locator_;
if (user_)
delete [] user_;
if (password_)
delete [] password_;
return result;
}
bool Client::Connect(
const String& locator,
const String& user,
const String& password,
Uint64 timeOutUsec)
{
m_rep->connectState = ClientRep::CONNECTSTATE_PENDING;
if (!ConnectAsync(locator, user, password))
return false;
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
// Wait for connection establishment or timeout.
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (m_rep->connectState != ClientRep::CONNECTSTATE_PENDING)
break;
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (m_rep->connectState != ClientRep::CONNECTSTATE_CONNECTED)
return false;
return true;
}
bool Client::Disconnect()
{
bool result = true;
// Fail if not connected:
if (!m_rep->protocol)
{
result = false;
goto done;
}
// Delete the protocol object.
{
Result r = Protocol_Delete(m_rep->protocol);
if (r != MI_RESULT_OK)
{
result = false;
goto done;
}
m_rep->protocol = 0;
}
m_rep->connectState = ClientRep::CONNECTSTATE_DISCONNECTED;
done:
return result;
}
bool Client::Connected() const
{
return m_rep->protocol ? true : false;
}
bool Client::Run(Uint64 timeOutUsec)
{
bool result = true;
// Fail if not connected.
if (!m_rep->protocol)
{
result = false;
goto done;
}
// Process events.
// ATTN: what can this return?
Protocol_Run(m_rep->protocol, timeOutUsec);
done:
return result;
}
bool Client::NoOpAsync(
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->NoOpAsync(msgID);
}
bool Client::GetInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->GetInstanceAsync(nameSpace, instanceName, msgID);
}
bool Client::CreateInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->CreateInstanceAsync(nameSpace, instance, msgID);
}
bool Client::ModifyInstanceAsync(
const String& nameSpace,
const DInstance& instance,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->ModifyInstanceAsync(nameSpace, instance, msgID);
}
bool Client::DeleteInstanceAsync(
const String& nameSpace,
const DInstance& instanceName,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->DeleteInstanceAsync(nameSpace, instanceName, msgID);
}
bool Client::EnumerateInstancesAsync(
const String& nameSpace,
const String& className,
bool deepInheritance,
const String& queryLanguage,
const String& queryExpression,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->EnumerateInstancesAsync(nameSpace, className,
deepInheritance, queryLanguage, queryExpression, msgID);
}
bool Client::InvokeAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& methodName,
const DInstance& inParameters,
DInstance& outParameters,
Uint64 msgID)
{
msgID = _NextMsgID();
return m_rep->InvokeAsync(nameSpace, instanceName, methodName, inParameters,
outParameters, msgID);
}
bool Client::AssociatorInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& resultClass,
const String& role,
const String& resultRole,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->AssociatorInstancesAsync(nameSpace, instanceName, assocClass,
resultClass, role, resultRole, msgID);
}
bool Client::ReferenceInstancesAsync(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& role,
Uint64& msgID)
{
msgID = _NextMsgID();
return m_rep->ReferenceInstancesAsync(nameSpace, instanceName, assocClass,
role, msgID);
}
bool Client::GetInstance(
const String& nameSpace,
const DInstance& instanceName,
Uint64 timeOutUsec,
DInstance& instance,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstanceHandler handler(oldHandler, msgID, instance);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->GetInstanceAsync(nameSpace, instanceName, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstanceHandler::FAILED ||
handler.m_state == InstanceHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstanceHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::CreateInstance(
const String& nameSpace,
const DInstance& instance,
Uint64 timeOutUsec,
DInstance& instanceName,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstanceHandler handler(oldHandler, msgID, instanceName);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->CreateInstanceAsync(nameSpace, instance, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstanceHandler::FAILED ||
handler.m_state == InstanceHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstanceHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::ModifyInstance(
const String& nameSpace,
const DInstance& instance,
Uint64 timeOutUsec,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
ResultHandler handler(oldHandler, msgID);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->ModifyInstanceAsync(nameSpace, instance, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == ResultHandler::FAILED ||
handler.m_state == ResultHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == ResultHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::DeleteInstance(
const String& nameSpace,
const DInstance& instanceName,
Uint64 timeOutUsec,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
ResultHandler handler(oldHandler, msgID);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->DeleteInstanceAsync(nameSpace, instanceName, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == ResultHandler::FAILED ||
handler.m_state == ResultHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == ResultHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::NoOp(Uint64 timeOutUsec)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
NoOpHandler handler(oldHandler, msgID);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->NoOpAsync(msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == NoOpHandler::FAILED ||
handler.m_state == NoOpHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state != NoOpHandler::DONE)
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::EnumerateInstances(
const String& nameSpace,
const String& className,
bool deepInheritance,
Uint64 timeOutUsec,
Array& instances,
const String& queryLanguage,
const String& queryExpression,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstancesHandler handler(oldHandler, msgID, instances);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->EnumerateInstancesAsync(nameSpace, className, deepInheritance,
queryLanguage, queryExpression, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstancesHandler::FAILED ||
handler.m_state == InstancesHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstancesHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::Invoke(
const String& nameSpace,
const DInstance& instanceName,
const String& methodName,
const DInstance& inParameters,
Uint64 timeOutUsec,
DInstance& outParameters,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstanceHandler handler(oldHandler, msgID, outParameters);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->InvokeAsync(nameSpace, instanceName, methodName, inParameters,
outParameters, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstanceHandler::FAILED ||
handler.m_state == InstanceHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstanceHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::AssociatorInstances(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& resultClass,
const String& role,
const String& resultRole,
Uint64 timeOutUsec,
Array& instances,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstancesHandler handler(oldHandler, msgID, instances);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->AssociatorInstancesAsync(nameSpace, instanceName, assocClass,
resultClass, role, resultRole, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstancesHandler::FAILED ||
handler.m_state == InstancesHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstancesHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
bool Client::ReferenceInstances(
const String& nameSpace,
const DInstance& instanceName,
const String& assocClass,
const String& role,
Uint64 timeOutUsec,
Array& instances,
Result& result)
{
Handler* oldHandler = m_rep->handler;
Uint64 msgID = _NextMsgID();
InstancesHandler handler(oldHandler, msgID, instances);
m_rep->handler = &handler;
bool flag = true;
if (!m_rep->ReferenceInstancesAsync(nameSpace, instanceName, assocClass,
role, msgID))
{
flag = false;
goto done;
}
Uint64 endTime, now;
if (Time_Now(&now) != MI_RESULT_OK)
return false;
endTime = now + timeOutUsec;
for (;endTime >= now;)
{
Protocol_Run(m_rep->protocol, 1000);
if (handler.m_state == InstancesHandler::FAILED ||
handler.m_state == InstancesHandler::DONE)
{
break;
}
if (Time_Now(&now) != MI_RESULT_OK)
break;
}
if (handler.m_state == InstancesHandler::DONE)
result = handler.m_result;
else
flag = false;
done:
m_rep->handler = oldHandler;
return flag;
}
MI_END_NAMESPACE