axis-c-dev mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From Uthaiyashankar <shan...@wso2.com>
Subject Re: Problem when running axis2c ws client in multiple threads
Date Mon, 07 Jan 2008 06:35:26 GMT
formatting of modified code is shown as *modified code* in the previous 
listing. so, please use the code listing given here.

Uthaiyashankar wrote:
> Hehe Zhou wrote:
>> 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
>>  
> Hi Zhou,
>
> The crashing is due to libxml in multi threaded environment. when 
> using libxml in multithreaded environment,
> (1) you have to call xmlInitParser() in the "main" thread before using 
> any of the libxml2 API. (Refer http://xmlsoft.org/threads.html)
> (2) should not call xmlCleanupParser() from individual threads. It can 
> be called from "main" thread at the end.
>
> By default, when destroying axis2_stub, it will call 
> xmlCleanupParser(). To disable it, after creating axis2_stub, the 
> option xml_parser_reset should be set to false.
>
> so, the modified code should be as given below.
>
> Regards,
> Shankar.
>
/*
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";
   axis2_options_t* options = NULL;

   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)
   {
       options = axis2_stub_get_options(stub, env);
       if (options)
       {
           axis2_options_set_xml_parser_reset(options, env, AXIS2_FALSE);
       }
       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[])
{
   axiom_xml_reader_init();
   _beginthread(run, 0, NULL);
   Sleep(5000);
   _beginthread(run, 0, NULL);
   Sleep(5000);
   axiom_xml_reader_cleanup();
   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;
}


---------------------------------------------------------------------
To unsubscribe, e-mail: axis-c-dev-unsubscribe@ws.apache.org
For additional commands, e-mail: axis-c-dev-help@ws.apache.org


Mime
View raw message