Hey,
The following program will crash when the second thread starts up [
_beginthread() in main() ]. A unhandled exception error is reported and
program crashes when 2nd thread starts to run ( 1st thread ends already).
This test program is just a multi-threaded version from Math sample
webservice client code of AXIS2. I just excute Math WS client twice in
different thread. But I don't have this problem if Math WS Client is run in
the same thread for two times. Any idea about this. I checked out the newest
AXIS2C code from SVN. Same problem happened.
Platform: WinXP
Compilor: Visual Studio 2005 Professional
// MathWSClient.cpp : Defines the entry point for the console application.
//
#include "axis2_math_stub.h"
#include <stdio.h>
#include <axiom.h>
#include <axis2_util.h>
#include <axiom_soap.h>
#include <axis2_client.h>
#include <iostream>
using namespace std;
axiom_node_t *
build_om_programatically(const axutil_env_t *env,
const axis2_char_t *operation,
const axis2_char_t *param1,
const axis2_char_t *param2);
void run(void* param)
{
axis2_stub_t *stub = NULL;
axiom_node_t *node = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axutil_env_t *env = NULL;
const axis2_char_t *address = NULL;
const axis2_char_t *client_home = NULL;
axiom_node_t *ret_node = NULL;
const axis2_char_t *operation = "add";
const axis2_char_t *param1 = "40";
const axis2_char_t *param2 = "8";
env = axutil_env_create_all("math_blocking.log", AXIS2_LOG_LEVEL_TRACE);
client_home = AXIS2_GETENV("AXIS2C_HOME");
if (!client_home || !strcmp (client_home, ""))
client_home = "../..";
address = "http://localhost:9090/axis2/services/math";;
printf("Using endpoint : %s\n", address);
printf("\nInvoking operation %s with params %s and %s\n", operation, param1,
param2);
node = build_om_programatically(env, operation, param1, param2);
stub =
axis2_math_stub_create_with_endpoint_uri_and_client_home(env, address,
client_home);
/* create node and invoke math */
if (stub)
{
ret_node = axis2_math_stub_add(stub, env, node);
}
if (ret_node)
{
if (axiom_node_get_node_type(ret_node, env) == AXIOM_ELEMENT)
{
axis2_char_t *result = NULL;
axiom_element_t *result_ele =
(axiom_element_t*)axiom_node_get_data_element(ret_node, env);
result = axiom_element_get_text(result_ele, env, ret_node);
printf("\nResult = %s\n", result);
}
else
{
axiom_xml_writer_t *writer = NULL;
axiom_output_t *om_output = NULL;
axis2_char_t *buffer = NULL;
writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_TRUE, 0,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_output = axiom_output_create(env, writer);
axiom_node_serialize(ret_node, env, om_output);
buffer = (axis2_char_t*)axiom_xml_writer_get_xml(writer, env);
printf("\nReceived invalid OM as result : %s\n", buffer);
if (buffer)
{
AXIS2_FREE(env->allocator, buffer);
buffer = NULL;
}
if (om_output)
{
axiom_output_free(om_output, env);
om_output = NULL;
}
axiom_xml_writer_free(writer, env);
}
}
else
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Stub invoke FAILED: Error code:"
" %d :: %s", env->error->error_number,
AXIS2_ERROR_GET_MESSAGE(env->error));
printf("math stub invoke FAILED!\n");
}
if (stub)
{
axis2_stub_free(stub, env);
}
if (env)
{
axutil_env_free((axutil_env_t *) env);
env = NULL;
}
_endthread();
}
int main(int argc, char* argv[])
{
_beginthread(run, 0, NULL);
Sleep(5000);
_beginthread(run, 0, NULL);
Sleep(5000);
return 0;
}
axiom_node_t *
build_om_programatically(const axutil_env_t *env,
const axis2_char_t *operation,
const axis2_char_t *param1,
const axis2_char_t *param2)
{
axiom_node_t *math_om_node = NULL;
axiom_element_t* math_om_ele = NULL;
axiom_node_t* text_om_node = NULL;
axiom_element_t * text_om_ele = NULL;
axiom_namespace_t *ns1 = NULL;
axiom_xml_writer_t *xml_writer = NULL;
axiom_output_t *om_output = NULL;
axis2_char_t *buffer = NULL;
ns1 = axiom_namespace_create(env, "http://ws.apache.org/axis2/services/math";,
"ns1");
math_om_ele = axiom_element_create(env, NULL, operation, ns1,
&math_om_node);
text_om_ele = axiom_element_create(env, math_om_node, "param1", NULL,
&text_om_node);
axiom_element_set_text(text_om_ele, env, param1, text_om_node);
text_om_ele = axiom_element_create(env, math_om_node, "param2", NULL,
&text_om_node);
axiom_element_set_text(text_om_ele, env, param2, text_om_node);
xml_writer = axiom_xml_writer_create_for_memory(env, NULL, AXIS2_FALSE,
AXIS2_FALSE,
AXIS2_XML_PARSER_TYPE_BUFFER);
om_output = axiom_output_create(env, xml_writer);
axiom_node_serialize(math_om_node, env, om_output);
buffer = (axis2_char_t*)axiom_xml_writer_get_xml(xml_writer, env);
AXIS2_LOG_DEBUG(env->log, AXIS2_LOG_SI, "\nSending OM node in XML : %s \n",
buffer);
if (om_output)
{
axiom_output_free(om_output, env);
om_output = NULL;
}
return math_om_node;
}
