bp::object WBEMConnection::pullInstanceNames(
bp::object &ctx,
bp::object &max_object_cnt) try
{
CIMEnumerationContext &ctx_ = CIMEnumerationContext::asNative(ctx, "Context");
Pegasus::Uint32 peg_max_object_cnt = Conv::as<Pegasus::Uint32>(
max_object_cnt, "MaxObjectCnt");
Pegasus::Array<Pegasus::CIMObjectPath> peg_instance_names;
Pegasus::Boolean peg_end_of_sequence;
ScopedTransactionBegin();
peg_instance_names = client()->pullInstancePaths(
ctx_.getPegasusContext(),
peg_end_of_sequence,
peg_max_object_cnt);
ScopedTransactionEnd();
return bp::make_tuple(
ListConv::asPyCIMInstanceNameList(peg_instance_names),
ctx,
bp::object(peg_end_of_sequence));
} catch (...) {
std::stringstream ss;
if (Config::isVerbose())
ss << "PullInstanceNames()";
handle_all_exceptions(ss);
return None;
}
void WBEMConnection::closeEnumeration(const bp::object &ctx) try
{
CIMEnumerationContext &ctx_ = CIMEnumerationContext::asNative(ctx, "Context");
ScopedTransactionBegin();
client()->closeEnumeration(ctx_.getPegasusContext());
ScopedTransactionEnd();
} catch (...) {
std::stringstream ss;
if (Config::isVerbose()) {
ss << "CloseEnumeration()";
}
handle_all_exceptions(ss);
}
bp::object WBEMConnection::openExecQuery(
const bp::object &query_lang,
const bp::object &query,
const bp::object &ns,
const bp::object &operation_timeout,
const bp::object &continue_on_error,
const bp::object &max_object_cnt) try
{
String c_query_lang(
StringConv::asString(query_lang, "QueryLanguage"));
String c_query(
StringConv::asString(query, "Query"));
Pegasus::CIMClass c_query_cls;
Pegasus::CIMNamespaceName peg_ns(m_default_namespace);
if (!isnone(ns))
peg_ns = StringConv::asString(ns, "namespace");
Pegasus::Uint32Arg peg_operation_timeout;
if (!isnone(operation_timeout)) {
peg_operation_timeout.setValue(Conv::as<Pegasus::Uint32>(
operation_timeout, "OperationTimeout"));
}
Pegasus::Boolean peg_continue_on_error = Conv::as<Pegasus::Boolean>(
continue_on_error, "ContinueOnError");
Pegasus::Uint32 peg_max_object_cnt = Conv::as<Pegasus::Uint32>(
max_object_cnt, "MaxObjectCount");
Pegasus::Array<Pegasus::CIMInstance> peg_instances;
boost::shared_ptr<Pegasus::CIMEnumerationContext> ctx_ptr(
make_enumeration_ctx());
Pegasus::Boolean peg_end_of_sequence;
ScopedTransactionBegin();
peg_instances = client()->openQueryInstances(
*ctx_ptr,
peg_end_of_sequence,
peg_ns,
c_query_lang,
c_query,
c_query_cls, // Unused: queryResultClass
false, // Unused: returnQueryResultClass
peg_operation_timeout,
peg_continue_on_error,
peg_max_object_cnt);
ScopedTransactionEnd();
return bp::make_tuple(
ListConv::asPyCIMInstanceList(
peg_instances,
peg_ns.getString(),
client()->getHostname()),
CIMEnumerationContext::create(
ctx_ptr,
false, /* with_paths */
peg_ns.getString()),
bp::object(peg_end_of_sequence));
} catch (...) {
std::stringstream ss;
if (Config::isVerbose()) {
ss << "OpenExecQuery(";
if (Config::isVerboseMore()) {
ss << "lang=u'" << StringConv::asString(query_lang) << "', "
<< "query=u'" << StringConv::asString(query) << '\'';
}
ss << ')';
}
handle_all_exceptions(ss);
return None;
}
bp::object WBEMConnection::openReferenceNames(
const bp::object &object_path,
const bp::object &ns,
const bp::object &result_class,
const bp::object &role,
const bp::object &query_lang,
const bp::object &query,
const bp::object &operation_timeout,
const bp::object &continue_on_error,
const bp::object &max_object_cnt) try
{
const CIMInstanceName &inst_name = CIMInstanceName::asNative(
object_path, "ObjectName");
Pegasus::CIMObjectPath peg_path = inst_name.asPegasusCIMObjectPath();
Pegasus::CIMNamespaceName peg_ns(m_default_namespace);
if (!peg_path.getNameSpace().isNull())
peg_ns = peg_path.getNameSpace().getString();
Pegasus::CIMName peg_result_class;
if (!isnone(result_class))
peg_result_class = StringConv::asString(result_class, "ResultClass");
String c_role;
if (!isnone(role))
c_role = StringConv::asString(role, "Role");
String c_query_lang;
String c_query;
if (!isnone(query_lang))
c_query_lang = StringConv::asString(query_lang);
if (!isnone(query))
c_query = StringConv::asString(query);
Pegasus::Boolean peg_continue_on_error = Conv::as<Pegasus::Boolean>(
continue_on_error, "ContinueOnError");
Pegasus::Uint32 peg_max_object_cnt = Conv::as<Pegasus::Uint32>(
max_object_cnt, "MaxObjectCount");
Pegasus::Uint32Arg peg_operation_timeout;
if (!isnone(operation_timeout)) {
peg_operation_timeout.setValue(Conv::as<Pegasus::Uint32>(
operation_timeout, "OperationTimeout"));
}
Pegasus::Array<Pegasus::CIMObjectPath> peg_reference_names;
boost::shared_ptr<Pegasus::CIMEnumerationContext> ctx_ptr(
make_enumeration_ctx());
Pegasus::Boolean peg_end_of_sequence;
ScopedTransactionBegin();
peg_reference_names = client()->openReferenceInstancePaths(
*ctx_ptr,
peg_end_of_sequence,
peg_ns,
peg_path,
peg_result_class,
c_role,
c_query_lang,
c_query,
peg_operation_timeout,
peg_continue_on_error,
peg_max_object_cnt);
ScopedTransactionEnd();
return bp::make_tuple(
ListConv::asPyCIMInstanceNameList(peg_reference_names),
CIMEnumerationContext::create(ctx_ptr),
bp::object(peg_end_of_sequence));
} catch (...) {
std::stringstream ss;
if (Config::isVerbose()) {
ss << "OpenReferenceNames(";
if (Config::isVerboseMore())
ss << '\'' << ObjectConv::asString(object_path) << '\'';
ss << ')';
}
handle_all_exceptions(ss);
return None;
}
bp::object WBEMConnection::openEnumerateInstanceNames(
const bp::object &cls,
const bp::object &ns,
const bp::object &query_lang,
const bp::object &query,
const bp::object &operation_timeout,
const bp::object &continue_on_error,
const bp::object &max_object_cnt) try
{
String c_cls(StringConv::asString(cls, "ClassName"));
String c_ns(m_default_namespace);
if (!isnone(ns))
c_ns = StringConv::asString(ns, "namespace");
Pegasus::CIMName peg_cls(c_cls);
Pegasus::CIMNamespaceName peg_ns(c_ns);
String c_query_lang;
String c_query;
if (!isnone(query_lang))
c_query_lang = StringConv::asString(query_lang);
if (!isnone(query))
c_query = StringConv::asString(query);
Pegasus::Boolean peg_continue_on_error = Conv::as<Pegasus::Boolean>(
continue_on_error, "ContinueOnError");
Pegasus::Uint32 peg_max_object_cnt = Conv::as<Pegasus::Uint32>(
max_object_cnt, "MaxObjectCount");
Pegasus::Uint32Arg peg_operation_timeout;
if (!isnone(operation_timeout)) {
peg_operation_timeout.setValue(Conv::as<Pegasus::Uint32>(
operation_timeout, "OperationTimeout"));
}
Pegasus::Array<Pegasus::CIMObjectPath> peg_instance_names;
boost::shared_ptr<Pegasus::CIMEnumerationContext> ctx_ptr(
make_enumeration_ctx());
Pegasus::Boolean peg_end_of_sequence;
ScopedTransactionBegin();
peg_instance_names = client()->openEnumerateInstancePaths(
*ctx_ptr,
peg_end_of_sequence,
peg_ns,
peg_cls,
c_query_lang,
c_query,
peg_operation_timeout,
peg_continue_on_error,
peg_max_object_cnt);
ScopedTransactionEnd();
return bp::make_tuple(
ListConv::asPyCIMInstanceNameList(peg_instance_names),
CIMEnumerationContext::create(ctx_ptr),
bp::object(peg_end_of_sequence));
} catch (...) {
std::stringstream ss;
if (Config::isVerbose()) {
ss << "OpenEnumerateInstanceNames(";
if (Config::isVerboseMore()) {
String c_ns(m_default_namespace);
if (!isnone(ns))
c_ns = StringConv::asString(ns);
ss << "classname=u" << StringConv::asString(cls) << ", "
<< "namespace=u" << c_ns;
}
ss << ')';
}
handle_all_exceptions(ss);
return None;
}
bp::object WBEMConnection::openEnumerateInstances(
const bp::object &cls,
const bp::object &ns,
const bp::object &deep_inheritance,
const bp::object &include_class_origin,
const bp::object &property_list,
const bp::object &query_lang,
const bp::object &query,
const bp::object &operation_timeout,
const bp::object &continue_on_error,
const bp::object &max_object_cnt) try
{
Pegasus::CIMName peg_cls(StringConv::asPegasusString(cls, "ClassName"));
Pegasus::CIMNamespaceName peg_ns(m_default_namespace.c_str());
if (!isnone(ns))
peg_ns = StringConv::asPegasusString(ns, "namespace");
Pegasus::String peg_query_lang;
Pegasus::String peg_query;
if (!isnone(query_lang))
peg_query_lang = StringConv::asPegasusString(query_lang);
if (!isnone(query))
peg_query = StringConv::asPegasusString(query);
Pegasus::Boolean peg_deep_inheritance = Conv::as<Pegasus::Boolean>(
deep_inheritance, "DeepInheritance");
Pegasus::Boolean peg_include_class_origin = Conv::as<Pegasus::Boolean>(
include_class_origin, "IncludeClassOrigin");
Pegasus::Boolean peg_continue_on_error = Conv::as<Pegasus::Boolean>(
continue_on_error, "ContinueOnError");
Pegasus::CIMPropertyList peg_property_list(
ListConv::asPegasusPropertyList(property_list,
"PropertyList"));
Pegasus::Uint32Arg peg_operation_timeout;
Pegasus::Uint32 peg_max_object_cnt = Conv::as<Pegasus::Uint32>(
max_object_cnt, "MaxObjectCount");
if (!isnone(operation_timeout)) {
peg_operation_timeout.setValue(Conv::as<Pegasus::Uint32>(
operation_timeout, "OperationTimeout"));
}
boost::shared_ptr<Pegasus::CIMEnumerationContext> ctx_ptr(
make_enumeration_ctx());
Pegasus::Array<Pegasus::CIMInstance> peg_instances;
Pegasus::Boolean peg_end_of_sequence;
ScopedTransactionBegin();
peg_instances = m_client.openEnumerateInstances(
*ctx_ptr,
peg_end_of_sequence,
peg_ns,
peg_cls,
peg_deep_inheritance,
peg_include_class_origin,
peg_property_list,
peg_query_lang,
peg_query,
peg_operation_timeout,
peg_continue_on_error,
peg_max_object_cnt);
ScopedTransactionEnd();
return bp::make_tuple(
ListConv::asPyCIMInstanceList(peg_instances),
CIMEnumerationContext::create(ctx_ptr),
bp::object(peg_end_of_sequence));
} catch (...) {
std::stringstream ss;
if (Config::isVerbose()) {
ss << "OpenEnumerateInstances(";
if (Config::isVerboseMore()) {
std::string std_ns(m_default_namespace);
if (!isnone(ns))
std_ns = StringConv::asStdString(ns);
ss << "classname=" << StringConv::asStdString(cls) << ", "
<< "namespace=" << std_ns;
}
ss << ')';
}
handle_all_exceptions(ss);
return None;
}