void
axis2_populate_axis_service(
axis2_stub_t * stub,
const axutil_env_t * env)
{
axis2_svc_client_t *svc_client = NULL;
axutil_qname_t *op_qname = NULL;
axis2_svc_t *svc = NULL;
axis2_op_t *op = NULL;
/*Modifying the Service */
svc_client = axis2_stub_get_svc_client(stub, env);
svc = axis2_svc_client_get_svc(svc_client, env);
/*creating the operations */
op_qname = axutil_qname_create(env, "add", "", NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_svc_add_op(svc, env, op);
axutil_qname_free(op_qname, env);
op_qname = axutil_qname_create(env, "sub", "", NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_svc_add_op(svc, env, op);
axutil_qname_free(op_qname, env);
op_qname = axutil_qname_create(env, "mul", "", NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_svc_add_op(svc, env, op);
axutil_qname_free(op_qname, env);
op_qname = axutil_qname_create(env, "div", "", NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_svc_add_op(svc, env, op);
axutil_qname_free(op_qname, env);
}
void
axis2_stub_populate_services_for_CallbackServiceUserStubService(axis2_stub_t *stub, const axutil_env_t *env)
{
axis2_svc_client_t *svc_client = NULL;
axutil_qname_t *svc_qname = NULL;
axutil_qname_t *op_qname = NULL;
axis2_svc_t *svc = NULL;
axis2_op_t *op = NULL;
axis2_op_t *annon_op = NULL;
axis2_msg_t *msg_out = NULL;
axis2_msg_t *msg_in = NULL;
axis2_msg_t *msg_out_fault = NULL;
axis2_msg_t *msg_in_fault = NULL;
/* Modifying the Service */
svc_client = axis2_stub_get_svc_client (stub, env );
svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, env );
annon_op = axis2_svc_get_op_with_name(svc, env, AXIS2_ANON_OUT_IN_OP);
msg_out = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT);
msg_in = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN);
msg_out_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT_FAULT);
msg_in_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN_FAULT);
svc_qname = axutil_qname_create(env,"CallbackServiceUserStubService" ,NULL, NULL);
axis2_svc_set_qname (svc, env, svc_qname);
/* creating the operations*/
op_qname = axutil_qname_create(env,
"getEvents" ,
"http://esb.callbackservice.services.hdviper.psnc.pl/",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_msg_increment_ref(msg_out, env);
axis2_msg_increment_ref(msg_in, env);
axis2_msg_increment_ref(msg_out_fault, env);
axis2_msg_increment_ref(msg_in_fault, env);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
axis2_svc_add_op(svc, env, op);
}
void AXIS2_CALL
axis2_stub_populate_services_for_IIp2Location(axis2_stub_t *stub, const axutil_env_t *env)
{
axis2_svc_client_t *svc_client = NULL;
axutil_qname_t *svc_qname = NULL;
axutil_qname_t *op_qname = NULL;
axis2_svc_t *svc = NULL;
axis2_op_t *op = NULL;
axis2_op_t *annon_op = NULL;
axis2_msg_t *msg_out = NULL;
axis2_msg_t *msg_in = NULL;
axis2_msg_t *msg_out_fault = NULL;
axis2_msg_t *msg_in_fault = NULL;
axis2_policy_include_t *policy_include = NULL;
axis2_desc_t *desc = NULL;
axiom_node_t *policy_node = NULL;
axiom_element_t *policy_root_ele = NULL;
neethi_policy_t *neethi_policy = NULL;
axis2_status_t status;
/* Modifying the Service */
svc_client = axis2_stub_get_svc_client (stub, env );
svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, env );
annon_op = axis2_svc_get_op_with_name(svc, env, AXIS2_ANON_OUT_IN_OP);
msg_out = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT);
msg_in = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN);
msg_out_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_OUT_FAULT);
msg_in_fault = axis2_op_get_msg(annon_op, env, AXIS2_MSG_IN_FAULT);
svc_qname = axutil_qname_create(env,"IIp2Location" ,NULL, NULL);
axis2_svc_set_qname (svc, env, svc_qname);
axutil_qname_free(svc_qname,env);
/* creating the operations*/
op_qname = axutil_qname_create(env,
"get" ,
"http://ws.apache.org/axis2",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axutil_qname_free(op_qname,env);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_msg_increment_ref(msg_out, env);
axis2_msg_increment_ref(msg_in, env);
axis2_msg_increment_ref(msg_out_fault, env);
axis2_msg_increment_ref(msg_in_fault, env);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
axis2_svc_add_op(svc, env, op);
op_qname = axutil_qname_create(env,
"add" ,
"http://ws.apache.org/axis2",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axutil_qname_free(op_qname,env);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_msg_increment_ref(msg_out, env);
axis2_msg_increment_ref(msg_in, env);
axis2_msg_increment_ref(msg_out_fault, env);
axis2_msg_increment_ref(msg_in_fault, env);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT, msg_out);
axis2_op_add_msg(op, env, AXIS2_MSG_IN, msg_in);
axis2_op_add_msg(op, env, AXIS2_MSG_OUT_FAULT, msg_out_fault);
axis2_op_add_msg(op, env, AXIS2_MSG_IN_FAULT, msg_in_fault);
axis2_svc_add_op(svc, env, op);
}
/* CHANGED */
void
wsf_util_create_op_and_add_to_svc (
wsf_svc_info_t * svc_info,
char *action,
axutil_env_t * env,
char *op_name,
VALUE ht_mep)
{
axis2_svc_t *svc = NULL;
axis2_op_t *op = NULL;
axutil_qname_t *op_qname = NULL;
op_qname = axutil_qname_create (env, op_name, NULL, NULL);
svc = svc_info->svc;
if (NULL != svc && NULL != op_name) {
op = axis2_svc_get_op_with_name (svc_info->svc, env, op_name);
if (!op) {
axis2_conf_t *conf = NULL;
axis2_conf_ctx_t *conf_ctx = NULL;
axis2_phases_info_t *info = NULL;
op_qname = axutil_qname_create (env, op_name, NULL, NULL);
op = axis2_op_create_with_qname (env, op_qname);
axis2_op_set_msg_recv (op, env, svc_info->msg_recv);
conf_ctx = wsf_worker_get_conf_ctx (svc_info->ruby_worker, env);
conf = axis2_conf_ctx_get_conf (conf_ctx, env);
info = axis2_conf_get_phases_info (conf, env);
axis2_phases_info_set_op_phases (info, env, op);
axis2_svc_add_op (svc_info->svc, env, op);
if (ht_mep) {
char operation[300];
VALUE mep_value;
char *mep;
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_service] ht mep not null, %s", op_name);
snprintf (operation, sizeof(operation), "%s", op_name);
if(TYPE(ht_mep) == T_HASH)
{
mep_value = rb_hash_aref(ht_mep, ID2SYM(rb_intern(operation)));
}
if(mep_value != Qnil)
{
mep = RSTRING(mep_value)->ptr;
if (mep) {
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_service] op mep %s", mep);
if (strcmp (mep, "IN_ONLY") == 0) {
axis2_op_set_msg_exchange_pattern (op, env,
AXIS2_MEP_URI_IN_ONLY);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_service] AXIS2_MEP_URI_IN_ONLY");
} else if (strcmp (mep, "IN_OUT") == 0) {
axis2_op_set_msg_exchange_pattern (op, env,
AXIS2_MEP_URI_IN_OUT);
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf_service] AXIS2_MEP_URI_IN_OUT");
}
}
}
else {
AXIS2_LOG_DEBUG (env->log, AXIS2_LOG_SI,
"[wsf service] message exchange pattern for %s not found",
op_name);
}
}
if (action) {
axis2_svc_add_mapping (svc_info->svc, env, action, op);
}
}
}
if(op_qname) {
axutil_qname_free(op_qname, env);
}
return;
}
bool Axis2UtilsCreateVirtualService(const staff::ServiceWrapper* pServiceWrapper,
const struct axutil_env* pEnv, struct axis2_conf* pConf)
{
if (!pServiceWrapper)
{
staff::LogError() << "pService is NULL";
return false;
}
const std::string& sServiceName = pServiceWrapper->GetName();
std::string sServiceGroupName = sServiceName + "SvcGroup";
std::string sServiceUri = "http://staff.tempui.org:9090/axis2/services/";
sServiceUri += sServiceName.c_str();
std::string sWsdlPath = staff::Runtime::Inst().GetComponentHome(pServiceWrapper->GetComponent()->GetName())
+ STAFF_PATH_SEPARATOR + pServiceWrapper->GetName() + ".wsdl";
axutil_qname_t* pQName = axutil_qname_create(pEnv, sServiceName.c_str(), sServiceUri.c_str(), NULL);
if (!pQName)
{
staff::LogError() << "pQName";
return false;
}
axis2_svc_t* pAxis2Service = axis2_svc_create_with_qname(pEnv, pQName);
if (!pAxis2Service)
{
axutil_qname_free(pQName, pEnv);
staff::LogError() << "pAxis2Service";
return false;
}
axutil_qname_free(pQName, pEnv);
// set "virtual" service flag
static char szParamName[] = "IsStaffVirtualService";
// allocate data C-way, so axis2/c can free it
int* pnParam = reinterpret_cast<int*>(AXIS2_MALLOC(pEnv->allocator, sizeof(int)));
if (!pnParam)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "can't allocate param";
return false;
}
*pnParam = 1;
axutil_param_t* pParam = axutil_param_create(pEnv, static_cast<axis2_char_t*>(szParamName), pnParam);
if (!pParam)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "pParam";
return false;
}
if (axis2_svc_add_param(pAxis2Service, pEnv, pParam) != AXIS2_SUCCESS)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "pParam";
return false;
}
{ // adding operations
const staff::DataObject& rdoOperations = pServiceWrapper->GetOperations();
for (staff::DataObject tdoOperation = rdoOperations.FirstChild();
!tdoOperation.IsNull(); tdoOperation.SetNextSibling())
{
const std::string& sOpName = tdoOperation.GetChildByLocalName("Name").GetText();
struct axis2_op* pOperation = axis2_op_create(pEnv);
pQName = axutil_qname_create(pEnv, sOpName.c_str(), NULL, NULL);
if (!pQName)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "pQName(op)";
return false;
}
if (axis2_op_set_qname(pOperation, pEnv, pQName) != AXIS2_SUCCESS)
{
axutil_qname_free(pQName, pEnv);
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_op_set_qname";
return false;
}
axutil_qname_free(pQName, pEnv);
// add REST params if exists
std::string sRestMethod;
std::string sRestLocation;
{
const staff::DataObject& rdoOperationConst = tdoOperation;
staff::DataObject::ConstIterator itRestTmp = rdoOperationConst.FindChildByLocalName("RestMethod");
if (itRestTmp != rdoOperationConst.End())
{
sRestMethod = itRestTmp->GetText();
}
itRestTmp = rdoOperationConst.FindChildByLocalName("RestLocation");
if (itRestTmp != rdoOperationConst.End())
{
sRestLocation = itRestTmp->GetText();
}
}
if (!sRestLocation.empty() && !sRestMethod.empty())
{
if (axis2_op_set_rest_http_method(pOperation, pEnv, sRestMethod.c_str()) != AXIS2_SUCCESS)
{
staff::LogError() << "Failed to set \"RESTMethod\" to service ["
<< sServiceName <<"] operation " << sOpName;
}
else
{
staff::LogDebug2() << "\"RESTMethod=" << sRestMethod << "\" param set to service ["
<< sServiceName <<"] operation " << sOpName;
}
if (axis2_op_set_rest_http_location(pOperation, pEnv, sRestLocation.c_str()) != AXIS2_SUCCESS)
{
staff::LogError() << "Failed to set \"RESTLocation\" to service ["
<< sServiceName <<"] operation " << sOpName;
}
else
{
staff::LogDebug2() << "\"RESTLocation=" << sRestLocation << "\" param set to service ["
<< sServiceName <<"] operation " << sOpName;
}
if (axis2_svc_add_rest_mapping(pAxis2Service, pEnv, sRestMethod.c_str(), sRestLocation.c_str(),
pOperation) != AXIS2_SUCCESS)
{
staff::LogError() << "Failed to set REST mapping to service ["
<< sServiceName <<"] operation " << sOpName;
}
}
// add service operation
if (axis2_svc_add_op(pAxis2Service, pEnv, pOperation) != AXIS2_SUCCESS)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_svc_add_op";
return false;
}
}
}
std::string sServiceDescr = pServiceWrapper->GetDescr();
FILE* pFile = fopen(sWsdlPath.c_str(), "rb");
if (pFile)
{
fclose(pFile);
sServiceDescr += " <sup>[<a style='font-size: x-small' href='/axis2/services/staff.wsdl.Wsdl/get/"
+ pServiceWrapper->GetComponent()->GetName() + "/"
+ pServiceWrapper->GetName() + ".wsdl'>wsdl</a>]</sup>";
if (axis2_svc_set_svc_wsdl_path(pAxis2Service, pEnv, sWsdlPath.c_str()) != AXIS2_SUCCESS)
{
staff::LogError() << "axis2_svc_set_svc_wsdl_path";
}
}
if (axis2_svc_set_svc_desc(pAxis2Service, pEnv, sServiceDescr.c_str()) != AXIS2_SUCCESS)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_svc_set_svc_desc";
return false;
}
// creating service group
axis2_svc_grp_t* pServiceGroup = axis2_svc_grp_create_with_conf(pEnv, pConf);
if (!pServiceGroup)
{
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_svc_grp_create_with_conf";
return false;
}
if (axis2_svc_grp_set_name(pServiceGroup, pEnv, sServiceGroupName.c_str()) != AXIS2_SUCCESS)
{
axis2_svc_grp_free(pServiceGroup, pEnv);
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_svc_grp_set_name";
return false;
}
if (axis2_svc_grp_add_svc(pServiceGroup, pEnv, pAxis2Service) != AXIS2_SUCCESS)
{
axis2_svc_grp_free(pServiceGroup, pEnv);
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_svc_grp_add_svc";
return false;
}
// adding to configuration
if (axis2_conf_add_svc_grp(pConf, pEnv, pServiceGroup) != AXIS2_SUCCESS)
{
axis2_svc_grp_free(pServiceGroup, pEnv);
axis2_svc_free(pAxis2Service, pEnv);
staff::LogError() << "axis2_conf_add_svc_grp";
return false;
}
return true;
}
void axis2_stub_ExchangeTrader_populate_services( axis2_stub_t *stub, const axutil_env_t *env)
{
axis2_svc_client_t *svc_client = NULL;
axutil_qname_t *svc_qname = NULL;
axutil_qname_t *op_qname = NULL;
axis2_svc_t *svc = NULL;
axis2_op_t *op = NULL;
/* Modifying the Service */
svc_client = axis2_stub_get_svc_client (stub, env );
svc = (axis2_svc_t*)axis2_svc_client_get_svc( svc_client, env );
axutil_qname_create(env,"ExchangeTrader" ,NULL, NULL);
axis2_svc_set_qname (svc, env, svc_qname);
/* creating the operations*/
op_qname = axutil_qname_create(env,
"buy" ,
"http://www.wso2.org",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_svc_add_op(svc, env, op);
op_qname = axutil_qname_create(env,
"login" ,
"http://www.wso2.org",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_svc_add_op(svc, env, op);
op_qname = axutil_qname_create(env,
"registerClient" ,
"http://www.wso2.org",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_IN);
axis2_svc_add_op(svc, env, op);
op_qname = axutil_qname_create(env,
"registerFeedTarget" ,
"http://www.wso2.org",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_svc_add_op(svc, env, op);
op_qname = axutil_qname_create(env,
"sell" ,
"http://www.wso2.org",
NULL);
op = axis2_op_create_with_qname(env, op_qname);
axis2_op_set_msg_exchange_pattern(op, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_svc_add_op(svc, env, op);
}
/**
* Here we extract all operations defined in module.xml and built execution
* chains for them by calling axis2_phase_resolver_build_execution_chains_for_module_op()
* function. Within that function handlers of the modules defined for that
* operation are added to module operation chains appropriately.
*/
AXIS2_EXTERN axis2_status_t AXIS2_CALL
axis2_svc_add_module_ops(
axis2_svc_t * svc,
const axutil_env_t * env,
axis2_module_desc_t * module_desc,
axis2_conf_t * conf)
{
axutil_hash_t *map = NULL;
axutil_hash_index_t *hash_idx = NULL;
axis2_phase_resolver_t *phase_resolver = NULL;
axis2_op_t *op_desc = NULL;
axis2_status_t status = AXIS2_FAILURE;
const axis2_char_t *svcname = NULL;
axis2_char_t *modname = NULL;
axis2_char_t *opname = NULL;
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Entry:axis2_svc_add_module_ops");
AXIS2_PARAM_CHECK(env->error, module_desc, AXIS2_FAILURE);
AXIS2_PARAM_CHECK(env->error, conf, AXIS2_FAILURE);
svcname = axis2_svc_get_name(svc, env);
modname = axutil_qname_get_localpart(axis2_module_desc_get_qname(module_desc, env), env);
map = axis2_module_desc_get_all_ops(module_desc, env);
phase_resolver = axis2_phase_resolver_create_with_config_and_svc(env, conf, svc);
if(!phase_resolver)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Creating phase resolver failed for service %s",
svcname);
return AXIS2_FAILURE;
}
for(hash_idx = axutil_hash_first(map, env); hash_idx; hash_idx = axutil_hash_next(env, hash_idx))
{
void *v = NULL;
axutil_hash_this(hash_idx, NULL, NULL, &v);
op_desc = (axis2_op_t *)v;
opname = axutil_qname_get_localpart(axis2_op_get_qname(op_desc, env), env);
status = axis2_phase_resolver_build_execution_chains_for_module_op(phase_resolver, env,
op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Builidng module operation %s failed for module %s", opname, modname);
return status;
}
status = axis2_svc_add_op(svc, env, op_desc);
if(AXIS2_SUCCESS != status)
{
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Adding operation %s to service %s failed",
opname, svcname);
return status;
}
}
axis2_phase_resolver_free(phase_resolver, env);
AXIS2_LOG_TRACE(env->log, AXIS2_LOG_SI, "Exit:axis2_svc_add_module_ops");
return AXIS2_SUCCESS;
}
static axis2_svc_t *
axis2_svc_client_create_annonymous_svc(
axis2_svc_client_t * svc_client,
const axutil_env_t * env)
{
/**
now add anonymous operations to the axis2 service for use with the
shortcut client API. NOTE: We only add the ones we know we'll use
later in the convenience API; if you use
this constructor then you can't expect any magic!
*/
axutil_qname_t *tmp_qname;
axis2_svc_t *svc;
axis2_op_t *op_out_in, *op_out_only, *op_robust_out_only;
axis2_phases_info_t *info = NULL;
tmp_qname = axutil_qname_create(env, AXIS2_ANON_SERVICE, NULL, NULL);
if(!tmp_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,"Error creating QName for service");
return NULL;
}
svc = axis2_svc_create_with_qname(env, tmp_qname);
axutil_qname_free(tmp_qname, env);
if(!svc)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error creating the service");
return NULL;
}
tmp_qname = axutil_qname_create(env, AXIS2_ANON_OUT_IN_OP, NULL, NULL);
if(!tmp_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error creating the QName for out-in operation");
return NULL;
}
op_out_in = axis2_op_create_with_qname(env, tmp_qname);
axutil_qname_free(tmp_qname, env);
tmp_qname = axutil_qname_create(env, AXIS2_ANON_OUT_ONLY_OP, NULL, NULL);
if(!tmp_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Error creating the QName for out-only operation");
return NULL;
}
op_out_only = axis2_op_create_with_qname(env, tmp_qname);
axutil_qname_free(tmp_qname, env);
tmp_qname = axutil_qname_create(env, AXIS2_ANON_ROBUST_OUT_ONLY_OP, NULL, NULL);
if(!tmp_qname)
{
AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI,
"Error creating the QName for robust-out-only operation");
return NULL;
}
op_robust_out_only = axis2_op_create_with_qname(env, tmp_qname);
axutil_qname_free(tmp_qname, env);
if(!op_out_in || !op_out_only || !op_robust_out_only)
{
AXIS2_ERROR_SET(env->error, AXIS2_ERROR_NO_MEMORY, AXIS2_FAILURE);
if(op_out_in)
{
axis2_op_free(op_out_in, env);
}
if(op_out_only)
{
axis2_op_free(op_out_only, env);
}
if(op_robust_out_only)
{
axis2_op_free(op_robust_out_only, env);
}
return NULL;
}
axis2_op_set_msg_exchange_pattern(op_out_in, env, AXIS2_MEP_URI_OUT_IN);
axis2_op_set_msg_exchange_pattern(op_out_only, env, AXIS2_MEP_URI_OUT_ONLY);
axis2_op_set_msg_exchange_pattern(op_robust_out_only, env, AXIS2_MEP_URI_ROBUST_OUT_ONLY);
/* Setting operation phase */
info = axis2_conf_get_phases_info(svc_client->conf, env);
axis2_phases_info_set_op_phases(info, env, op_out_in);
axis2_phases_info_set_op_phases(info, env, op_out_only);
axis2_phases_info_set_op_phases(info, env, op_robust_out_only);
axis2_svc_add_op(svc, env, op_out_in);
axis2_svc_add_op(svc, env, op_out_only);
axis2_svc_add_op(svc, env, op_robust_out_only);
return svc;
}
