int main(int argc, char** argv)
{
WsManClient *cl;
WsXmlDocH doc;
client_opt_t *options = NULL;
printf ("Test 1: Testin Identify Request:");
cl = wsmc_create( sd[0].server,
sd[0].port,
sd[0].path,
sd[0].scheme,
sd[0].username,
sd[0].password);
wsmc_transport_init(cl, NULL);
options = wsmc_options_init();
doc = wsmc_action_identify(cl, options);
if (!doc) {
printf("\t\t\033[22;31mUNRESOLVED\033[m\n");
goto CONTINUE;
}
char *xp = ws_xml_get_xpath_value(doc, "/s:Envelope/s:Body/wsmid:IdentifyResponse/wsmid:ProtocolVersion");
if (xp)
{
if (strcmp(xp,XML_NS_WS_MAN ) == 0)
printf("\t\t\033[22;32mPASSED\033[m\n");
else
printf("\t\t\033[22;31mFAILED\033[m\n");
u_free(xp);
} else {
printf("\t\t\033[22;31mFAILED\033[m\n");
}
if (doc) {
ws_xml_destroy_doc(doc);
}
CONTINUE:
wsmc_options_destroy(options);
wsmc_release(cl);
return 0;
}
static virDrvOpenStatus
hypervConnectOpen(virConnectPtr conn, virConnectAuthPtr auth, unsigned int flags)
{
virDrvOpenStatus result = VIR_DRV_OPEN_ERROR;
char *plus;
hypervPrivate *priv = NULL;
char *username = NULL;
char *password = NULL;
virBuffer query = VIR_BUFFER_INITIALIZER;
Msvm_ComputerSystem *computerSystem = NULL;
virCheckFlags(VIR_CONNECT_RO, VIR_DRV_OPEN_ERROR);
/* Decline if the URI is NULL or the scheme is NULL */
if (conn->uri == NULL || conn->uri->scheme == NULL) {
return VIR_DRV_OPEN_DECLINED;
}
/* Decline if the scheme is not hyperv */
plus = strchr(conn->uri->scheme, '+');
if (plus == NULL) {
if (STRCASENEQ(conn->uri->scheme, "hyperv")) {
return VIR_DRV_OPEN_DECLINED;
}
} else {
if (plus - conn->uri->scheme != 6 ||
STRCASENEQLEN(conn->uri->scheme, "hyperv", 6)) {
return VIR_DRV_OPEN_DECLINED;
}
virReportError(VIR_ERR_INVALID_ARG,
_("Transport '%s' in URI scheme is not supported, try again "
"without the transport part"), plus + 1);
return VIR_DRV_OPEN_ERROR;
}
/* Require server part */
if (conn->uri->server == NULL) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("URI is missing the server part"));
return VIR_DRV_OPEN_ERROR;
}
/* Require auth */
if (auth == NULL || auth->cb == NULL) {
virReportError(VIR_ERR_INVALID_ARG, "%s",
_("Missing or invalid auth pointer"));
return VIR_DRV_OPEN_ERROR;
}
/* Allocate per-connection private data */
if (VIR_ALLOC(priv) < 0)
goto cleanup;
if (hypervParseUri(&priv->parsedUri, conn->uri) < 0) {
goto cleanup;
}
/* Set the port dependent on the transport protocol if no port is
* specified. This allows us to rely on the port parameter being
* correctly set when building URIs later on, without the need to
* distinguish between the situations port == 0 and port != 0 */
if (conn->uri->port == 0) {
if (STRCASEEQ(priv->parsedUri->transport, "https")) {
conn->uri->port = 5986;
} else {
conn->uri->port = 5985;
}
}
/* Request credentials */
if (conn->uri->user != NULL) {
if (VIR_STRDUP(username, conn->uri->user) < 0)
goto cleanup;
} else {
username = virAuthGetUsername(conn, auth, "hyperv", "administrator", conn->uri->server);
if (username == NULL) {
virReportError(VIR_ERR_AUTH_FAILED, "%s", _("Username request failed"));
goto cleanup;
}
}
password = virAuthGetPassword(conn, auth, "hyperv", username, conn->uri->server);
if (password == NULL) {
virReportError(VIR_ERR_AUTH_FAILED, "%s", _("Password request failed"));
goto cleanup;
}
/* Initialize the openwsman connection */
priv->client = wsmc_create(conn->uri->server, conn->uri->port, "/wsman",
priv->parsedUri->transport, username, password);
if (priv->client == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not create openwsman client"));
goto cleanup;
}
if (wsmc_transport_init(priv->client, NULL) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not initialize openwsman transport"));
goto cleanup;
}
/* FIXME: Currently only basic authentication is supported */
wsman_transport_set_auth_method(priv->client, "basic");
/* Check if the connection can be established and if the server has the
* Hyper-V role installed. If the call to hypervGetMsvmComputerSystemList
* succeeds than the connection has been established. If the returned list
* is empty than the server isn't a Hyper-V server. */
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "where ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_PHYSICAL);
if (hypervGetMsvmComputerSystemList(priv, &query, &computerSystem) < 0) {
goto cleanup;
}
if (computerSystem == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s is not a Hyper-V server"), conn->uri->server);
goto cleanup;
}
conn->privateData = priv;
priv = NULL;
result = VIR_DRV_OPEN_SUCCESS;
cleanup:
hypervFreePrivate(&priv);
VIR_FREE(username);
VIR_FREE(password);
hypervFreeObject(priv, (hypervObject *)computerSystem);
return result;
}
int main(int argc, char** argv)
{
int i;
int choice = 0;
WsManClient *cl;
WsXmlDocH doc;
client_opt_t *options = NULL;
WsXmlDocH resource = NULL;
if (getenv("OPENWSMAN_TEST_HOST")) {
host = getenv("OPENWSMAN_TEST_HOST");
}
resource = wsmc_read_file("./requests/create.xml", "UTF-8", 0);
if(argc > 1)
choice = atoi(argv[1]);
for (i = 0; i < ntests; i++)
{
if(choice && i != choice -1)
continue;
if (tests[i].selectors) {
tests[i].selectors = u_strdup_printf(tests[i].selectors, host, host, host);
}
if (tests[i].expected_value) {
tests[i].expected_value = u_strdup_printf(tests[i].expected_value, host, host, host);
}
printf ("Test %3d: %s ", i + 1, tests[i].explanation);
cl = wsmc_create(
sd[0].server,
sd[0].port,
sd[0].path,
sd[0].scheme,
sd[0].username,
sd[0].password);
wsmc_transport_init(cl, NULL);
options = wsmc_options_init();
if (tests[i].selectors != NULL)
wsmc_add_selectors_from_str (options, tests[i].selectors);
wsmc_set_action_option(options, FLAG_DUMP_REQUEST);
doc = wsmc_action_create(cl, (char *)tests[i].resource_uri, options, resource);
if (!doc) {
printf("\t\t\033[22;31mUNRESOLVED\033[m\n");
goto CONTINUE;
}
wsman_output(doc);
if (tests[i].final_status != wsmc_get_response_code(cl)) {
printf("Status = %ld \t\t\033[22;31mFAILED\033[m\n",
wsmc_get_response_code(cl));
goto CONTINUE;
}
if ((char *)tests[i].expected_value != NULL)
{
char *xp = ws_xml_get_xpath_value(doc, (char *)tests[i].xpath_expression);
if (xp)
{
if (strcmp(xp,(char *)tests[i].expected_value ) == 0)
printf("\t\t\033[22;32mPASSED\033[m\n");
else
printf("%s = %s\t\033[22;31mFAILED\033[m\n",(char *)tests[i].xpath_expression, xp);
u_free(xp);
} else {
printf(" No %s\t\033[22;31mFAILED\033[m\n", (char *)tests[i].xpath_expression);
ws_xml_dump_node_tree(stdout, ws_xml_get_doc_root(doc));
}
} else {
printf("\t\t\033[22;32mPASSED\033[m\n");
}
ws_xml_destroy_doc(doc);
CONTINUE:
u_free(tests[i].selectors);
u_free(tests[i].expected_value);
wsmc_options_destroy(options);
wsmc_release(cl);
}
return 0;
}
static int
hypervInitConnection(virConnectPtr conn, hypervPrivate *priv,
char *username, char *password)
{
virBuffer query = VIR_BUFFER_INITIALIZER;
hypervWqlQuery wqlQuery = HYPERV_WQL_QUERY_INITIALIZER;
hypervObject *computerSystem = NULL;
int ret = -1;
/* Initialize the openwsman connection */
priv->client = wsmc_create(conn->uri->server, conn->uri->port, "/wsman",
priv->parsedUri->transport, username, password);
if (priv->client == NULL) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not create openwsman client"));
goto cleanup;
}
if (wsmc_transport_init(priv->client, NULL) != 0) {
virReportError(VIR_ERR_INTERNAL_ERROR, "%s",
_("Could not initialize openwsman transport"));
goto cleanup;
}
/* FIXME: Currently only basic authentication is supported */
wsman_transport_set_auth_method(priv->client, "basic");
wqlQuery.info = Msvm_ComputerSystem_WmiInfo;
wqlQuery.query = &query;
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "WHERE ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_PHYSICAL);
/* try query using V2 namespace (for Hyper-V 2012+) */
priv->wmiVersion = HYPERV_WMI_VERSION_V2;
if (hypervEnumAndPull(priv, &wqlQuery, &computerSystem) < 0) {
/* rebuild query because hypervEnumAndPull consumes it */
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_SELECT);
virBufferAddLit(&query, "WHERE ");
virBufferAddLit(&query, MSVM_COMPUTERSYSTEM_WQL_PHYSICAL);
/* fall back to V1 namespace (for Hyper-V 2008) */
priv->wmiVersion = HYPERV_WMI_VERSION_V1;
if (hypervEnumAndPull(priv, &wqlQuery, &computerSystem) < 0) {
virReportError(VIR_ERR_INTERNAL_ERROR,
_("%s is not a Hyper-V server"), conn->uri->server);
goto cleanup;
}
}
ret = 0;
cleanup:
hypervFreeObject(priv, computerSystem);
return ret;
}
int main(int argc, char** argv)
{
int i;
WsManClient *cl;
WsXmlDocH docp;
client_opt_t *options = NULL;
char *enumContext = NULL;
//unsigned int id = 0;
//wsman_debug_set_level(DEBUG_LEVEL_DEBUG);
initialize_logging();
//wsmc_add_handler(wsmc_handler, NULL);
for (i = 0; i < ntests; i++)
{
printf ("Test %d: %s:", i + 1, tests[i].explanation);
//printf ("------------------------------------------------\n");
cl = wsmc_create(
sd[0].server,
sd[0].port,
sd[0].path,
sd[0].scheme,
sd[0].username,
sd[0].password);
wsmc_transport_init(cl, NULL);
options = wsmc_options_init();
options->flags = tests[i].flags;
options->max_elements = tests[i].max_elements;
if (tests[i].selectors != NULL)
wsmc_add_selectors_from_str (options, tests[i].selectors);
WsXmlDocH enum_response = wsmc_action_enumerate(cl, (char *)tests[i].resource_uri ,
options, NULL);
if (!enum_response) {
printf("\t\t\033[22;31mUNRESOLVED\033[m\n");
goto CONTINUE;
} //wsman_output(enum_response);
if ((char *)tests[i].expected_value != NULL) {
char *xp = ws_xml_get_xpath_value(enum_response,
(char *)tests[i].xpath_expression);
if (xp) {
if (strcmp(xp,(char *)tests[i].expected_value ) == 0)
printf("\t\t\033[22;32mPASSED\033[m\n");
else
printf("\t\t\033[22;31mFAILED\033[m\n");
u_free(xp);
}
}
wsmc_free_enum_context(enumContext);
enumContext = wsmc_get_enum_context(enum_response);
ws_xml_destroy_doc(enum_response);
while (enumContext != NULL)
{
docp = wsmc_action_pull(cl, (char *)tests[i].resource_uri,
options, NULL, enumContext);
if (!docp) {
printf("\t\t\033[22;31mUNRESOLVED\033[m\n");
goto CONTINUE;
}
wsman_output(docp);
wsmc_free_enum_context(enumContext);
enumContext = wsmc_get_enum_context(docp);
ws_xml_destroy_doc(docp);
}
CONTINUE:
wsmc_options_destroy(options);
wsmc_release(cl);
}
return 0;
}
