/* create service */ void wsf_util_create_svc_from_svc_info ( wsf_svc_info_t * svc_info, axutil_env_t * env) { axutil_qname_t *svc_qname = NULL; axis2_svc_t *svc = NULL; axis2_conf_t *conf = NULL; axis2_conf_ctx_t *conf_ctx = NULL; if (!svc_info->ruby_worker) { /* php_error_docref (NULL TSRMLS_CC, E_ERROR, "error creating service"); */ return; } conf_ctx = wsf_worker_get_conf_ctx (svc_info->ruby_worker, env); conf = axis2_conf_ctx_get_conf (conf_ctx, env); if (!conf) { /* php_error_docref (NULL TSRMLS_CC, E_ERROR, "error creating qname"); */ return; } svc = axis2_conf_get_svc (conf, env, svc_info->svc_name); if (NULL != svc) { svc_info->svc = svc; } else { svc_qname = axutil_qname_create (env, svc_info->svc_name, NULL, NULL); svc_info->svc = axis2_svc_create_with_qname (env, svc_qname); axutil_qname_free (svc_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_test_conf_ctx_init(axutil_env_t *env ) { struct axis2_conf *conf = NULL; struct axis2_svc_grp_ctx *svc_grp_ctx1 = NULL; struct axis2_svc_grp_ctx *svc_grp_ctx2 = NULL; struct axis2_svc_grp *svc_grp1 = NULL; struct axis2_svc_grp *svc_grp2 = NULL; struct axis2_conf_ctx *conf_ctx = NULL; struct axis2_svc_ctx *svc_ctx1 = NULL; struct axis2_svc_ctx *svc_ctx2 = NULL; struct axis2_svc *svc1 = NULL; struct axis2_svc *svc2 = NULL; struct axutil_qname *qname1 = NULL; struct axutil_qname *qname2 = NULL; struct axis2_op_ctx *op_ctx1 = NULL; struct axis2_op_ctx *op_ctx2 = NULL; struct axis2_op *op = NULL; struct axutil_hash_t *op_ctx_map = NULL; struct axutil_hash_t *svc_ctx_map = NULL; struct axutil_hash_t *svc_grp_ctx_map = NULL; axis2_status_t status = AXIS2_FAILURE; conf = axis2_conf_create(env); CUT_ASSERT_PTR_NOT_EQUAL(conf, NULL, 1); conf_ctx = axis2_conf_ctx_create(env, conf); CUT_ASSERT_PTR_NOT_EQUAL(conf_ctx, NULL, 1); svc_grp1 = axis2_svc_grp_create(env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp1, NULL, 0); svc_grp2 = axis2_svc_grp_create(env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp2, NULL, 0); svc_grp_ctx1 = axis2_svc_grp_ctx_create(env, svc_grp1, conf_ctx); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx1, NULL, 0); svc_grp_ctx2 = axis2_svc_grp_ctx_create(env, svc_grp2, conf_ctx); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx2, NULL, 0); qname1 = axutil_qname_create(env, "name1", NULL, NULL); CUT_ASSERT_PTR_NOT_EQUAL(qname1, NULL, 0); qname2 = axutil_qname_create(env, "name2", NULL, NULL); CUT_ASSERT_PTR_NOT_EQUAL(qname2, NULL, 0); svc1 = axis2_svc_create_with_qname(env, qname1); CUT_ASSERT_PTR_NOT_EQUAL(svc1, NULL, 0); svc2 = axis2_svc_create_with_qname(env, qname2); CUT_ASSERT_PTR_NOT_EQUAL(svc2, NULL, 0); svc_ctx1 = axis2_svc_ctx_create(env, svc1, svc_grp_ctx1); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx1, NULL, 0); svc_ctx2 = axis2_svc_ctx_create(env, svc2, svc_grp_ctx2); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx1, NULL, 0); op = axis2_op_create(env); CUT_ASSERT_PTR_NOT_EQUAL(op, NULL, 0); op_ctx1 = axis2_op_ctx_create(env, op, svc_ctx1); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx1, NULL, 0); op_ctx2 = axis2_op_ctx_create(env, op, svc_ctx2); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx2, NULL, 0); op_ctx_map = axis2_conf_ctx_get_op_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(op_ctx_map, NULL, 0); if (op_ctx_map) { axutil_hash_set(op_ctx_map, "op_ctx1", AXIS2_HASH_KEY_STRING, op_ctx1); axutil_hash_set(op_ctx_map, "op_ctx2", AXIS2_HASH_KEY_STRING, op_ctx2); } svc_ctx_map = axis2_conf_ctx_get_svc_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(svc_ctx_map, NULL, 0); if (svc_ctx_map) { axutil_hash_set(svc_ctx_map, "svc_ctx1", AXIS2_HASH_KEY_STRING, svc_ctx1); axutil_hash_set(svc_ctx_map, "svc_ctx2", AXIS2_HASH_KEY_STRING, svc_ctx2); } svc_grp_ctx_map = axis2_conf_ctx_get_svc_grp_ctx_map(conf_ctx, env); CUT_ASSERT_PTR_NOT_EQUAL(svc_grp_ctx_map, NULL, 0); if (svc_grp_ctx_map) { axutil_hash_set(svc_ctx_map, "svc_grp_ctx1", AXIS2_HASH_KEY_STRING, svc_grp_ctx1); axutil_hash_set(svc_ctx_map, "svc_grp_ctx2", AXIS2_HASH_KEY_STRING, svc_grp_ctx2); } status = axis2_conf_ctx_init(conf_ctx, env, conf); CUT_ASSERT_INT_EQUAL(status, AXIS2_SUCCESS, 0); printf("Error code : %d\n", env->error->error_number); /* CUT_ASSERT_INT_EQUAL(env->error->status_code, AXIS2_SUCCESS, 0); */ /* To avoid warning of not using cut_str_equal */ CUT_ASSERT_STR_EQUAL("", "", 0); axis2_conf_ctx_free(conf_ctx, env); }
AXIS2_EXTERN axis2_status_t AXIS2_CALL axis2_svc_grp_builder_populate_svc_grp( axis2_svc_grp_builder_t * svc_grp_builder, const axutil_env_t * env, axis2_svc_grp_t * svc_grp) { axiom_children_qname_iterator_t *itr = NULL; axiom_children_qname_iterator_t *module_ref_itr = NULL; axiom_children_qname_iterator_t *svc_itr = NULL; axutil_qname_t *qparamst = NULL; axutil_qname_t *qmodulest = NULL; axutil_qname_t *qsvc_element = NULL; axiom_element_t *svc_grp_element = NULL; axis2_status_t status = AXIS2_FAILURE; axis2_conf_t *parent = NULL; /* Processing service level paramters */ svc_grp_element = axiom_node_get_data_element(svc_grp_builder->svc_grp, env); qparamst = axutil_qname_create(env, AXIS2_PARAMETERST, NULL, NULL); itr = axiom_element_get_children_with_qname(svc_grp_element, env, qparamst, svc_grp_builder->svc_grp); if(qparamst) { axutil_qname_free(qparamst, env); qparamst = NULL; } parent = axis2_svc_grp_get_parent(svc_grp, env); status = axis2_desc_builder_process_params(svc_grp_builder->desc_builder, env, itr, axis2_svc_grp_get_param_container(svc_grp, env), axis2_conf_get_param_container(parent, env)); /* Processing service modules required to be engaged globally */ qmodulest = axutil_qname_create(env, AXIS2_MODULEST, NULL, NULL); module_ref_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qmodulest, svc_grp_builder-> svc_grp); if(qmodulest) { axutil_qname_free(qmodulest, env); qmodulest = NULL; } axis2_svc_grp_builder_process_module_refs(svc_grp_builder, env, module_ref_itr, svc_grp); qsvc_element = axutil_qname_create(env, AXIS2_SVC_ELEMENT, NULL, NULL); svc_itr = axiom_element_get_children_with_qname(svc_grp_element, env, qsvc_element, svc_grp_builder->svc_grp); if(qsvc_element) { axutil_qname_free(qsvc_element, env); qsvc_element = NULL; } while(axiom_children_qname_iterator_has_next(svc_itr, env)) { axiom_node_t *svc_node = NULL; axiom_element_t *svc_element = NULL; axiom_attribute_t *svc_name_att = NULL; axis2_char_t *svc_name = NULL; axutil_qname_t *qattname = NULL; svc_node = (axiom_node_t *)axiom_children_qname_iterator_next(svc_itr, env); svc_element = axiom_node_get_data_element(svc_node, env); qattname = axutil_qname_create(env, AXIS2_ATTNAME, NULL, NULL); svc_name_att = axiom_element_get_attribute(svc_element, env, qattname); if(qattname) { axutil_qname_free(qattname, env); qattname = NULL; } svc_name = axiom_attribute_get_value(svc_name_att, env); if(!svc_name) { AXIS2_ERROR_SET(env->error, AXIS2_ERROR_SVC_NAME_ERROR, AXIS2_FAILURE); AXIS2_LOG_ERROR(env->log, AXIS2_LOG_SI, "Service name attribute has no value"); return AXIS2_FAILURE; } else { axis2_svc_t *axis_svc = NULL; axis2_arch_file_data_t *file_data = NULL; axutil_array_list_t *deployable_svcs = NULL; axis2_svc_builder_t *svc_builder = NULL; file_data = axis2_dep_engine_get_current_file_item(axis2_desc_builder_get_dep_engine( svc_grp_builder->desc_builder, env), env); axis_svc = axis2_arch_file_data_get_svc(file_data, env, svc_name); if(!axis_svc) { axutil_qname_t *qsvc_name = NULL; qsvc_name = axutil_qname_create(env, svc_name, NULL, NULL); axis_svc = axis2_svc_create_with_qname(env, qsvc_name); axutil_qname_free(qsvc_name, env); axis2_arch_file_data_add_svc(file_data, env, axis_svc); } /* Adding service to the deployable services list */ deployable_svcs = axis2_arch_file_data_get_deployable_svcs(file_data, env); axutil_array_list_add(deployable_svcs, env, axis_svc); axis2_svc_set_parent(axis_svc, env, svc_grp); svc_builder = axis2_svc_builder_create_with_dep_engine_and_svc(env, axis2_desc_builder_get_dep_engine(svc_grp_builder-> desc_builder, env), axis_svc); status = axis2_svc_builder_populate_svc(svc_builder, env, svc_node); axis2_svc_builder_free(svc_builder, env); } } return status; }
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; }