/** @throws Exception */ private void initialize() throws Exception { loadSecurityScenarios(); STSConfigAdmin.configureService( configContext.getAxisConfiguration(), this.registryService.getConfigSystemRegistry()); STSConfigAdmin.configureGenericSTS(); configContext.getAxisConfiguration().addObservers(new STSObserver()); }
/** {@inheritDoc} */ public SynapseConfiguration createSynapseConfiguration() { String synapseXMLLocation = serverConfigurationInformation.getSynapseXMLLocation(); Properties properties = SynapsePropertiesLoader.loadSynapseProperties(); if (serverConfigurationInformation.getResolveRoot() != null) { properties.put( SynapseConstants.RESOLVE_ROOT, serverConfigurationInformation.getResolveRoot()); } if (serverConfigurationInformation.getSynapseHome() != null) { properties.put( SynapseConstants.SYNAPSE_HOME, serverConfigurationInformation.getSynapseHome()); } if (synapseXMLLocation != null) { synapseConfiguration = SynapseConfigurationBuilder.getConfiguration(synapseXMLLocation, properties); } else { log.warn( "System property or init-parameter '" + SynapseConstants.SYNAPSE_XML + "' is not specified. Using default configuration.."); synapseConfiguration = SynapseConfigurationBuilder.getDefaultConfiguration(); } Enumeration keys = properties.keys(); while (keys.hasMoreElements()) { String key = (String) keys.nextElement(); synapseConfiguration.setProperty(key, properties.getProperty(key)); } // Set the Axis2 ConfigurationContext to the SynapseConfiguration synapseConfiguration.setAxisConfiguration(configurationContext.getAxisConfiguration()); MessageContextCreatorForAxis2.setSynConfig(synapseConfiguration); // set the Synapse configuration into the Axis2 configuration Parameter synapseConfigurationParameter = new Parameter(SynapseConstants.SYNAPSE_CONFIG, synapseConfiguration); try { configurationContext.getAxisConfiguration().addParameter(synapseConfigurationParameter); } catch (AxisFault e) { handleFatal( "Could not set parameters '" + SynapseConstants.SYNAPSE_CONFIG + "' to the Axis2 configuration : " + e.getMessage(), e); } addServerIPAndHostEntries(); return synapseConfiguration; }
public static ConfigurationContext createClientConfigurationContext() throws AxisFault { File file = getAddressingMARFile(); TestCase.assertTrue(file.exists()); ConfigurationContext configContext = ConfigurationContextFactory.createConfigurationContextFromFileSystem( "target/test-resources/integrationRepo", "target/test-resources/integrationRepo/conf/axis2.xml"); AxisModule axisModule = DeploymentEngine.buildModule(file, configContext.getAxisConfiguration()); configContext.getAxisConfiguration().addModule(axisModule); return configContext; }
private void addDeployers(ConfigurationContext configurationContext) { AxisConfiguration axisConfig = configurationContext.getAxisConfiguration(); DeploymentEngine deploymentEngine = (DeploymentEngine) axisConfig.getConfigurator(); String carbonRepoPath = configurationContext.getAxisConfiguration().getRepository().getFile(); String mediatorsPath = carbonRepoPath + File.separator + "mediators"; String extensionsPath = carbonRepoPath + File.separator + "extensions"; ExtensionDeployer deployer = new ExtensionDeployer(); deploymentEngine.addDeployer(deployer, mediatorsPath, "xar"); deploymentEngine.addDeployer(deployer, extensionsPath, "xar"); deploymentEngine.addDeployer(deployer, mediatorsPath, "jar"); deploymentEngine.addDeployer(deployer, extensionsPath, "jar"); }
/** * Adds the synapse handlers to the inflow Dispatch phase and starts the listener manager if the * axis2 instance is created by the Synapse */ public void start() { // add the Synapse handlers if (configurationContext != null) { List<Phase> inflowPhases = configurationContext.getAxisConfiguration().getInFlowPhases(); for (Phase inPhase : inflowPhases) { // we are interested about the Dispatch phase in the inflow if (PhaseMetadata.PHASE_DISPATCH.equals(inPhase.getPhaseName())) { try { inPhase.addHandler(prepareSynapseDispatcher()); inPhase.addHandler(prepareMustUnderstandHandler()); } catch (PhaseException e) { handleFatal("Couldn't start Synapse, " + "Cannot add the required Synapse handlers", e); } } } } else { handleFatal("Couldn't start Synapse, ConfigurationContext not found"); } // if the axis2 instance is created by us, then start the listener manager if (serverConfigurationInformation.isCreateNewInstance()) { if (listenerManager != null) { listenerManager.start(); } else { handleFatal("Couldn't start Synapse, ListenerManager not found"); } /* if JMX Adapter has been configured and started, output usage information rather at the end of the startup process to make it more obvious */ if (jmxAdapter != null && jmxAdapter.isRunning()) { log.info( "Management using JMX available via: " + jmxAdapter.getJmxInformation().getJmxUrl()); } } }
/** * Search the service artifacts stored in the registry and find the set of services that satisfy * the conditions stated in the given WS-D probe. If the probe does not impose any restrictions on * the result set, all the services in the registry will be returned. * * @param probe a WS-D probe describing the search criteria * @return an array of TargetService instances matching the probe or null * @throws Exception if an error occurs while accessing the registry */ public static TargetService[] findServices(Probe probe) throws Exception { ServiceManager serviceManager = new ServiceManager(getRegistry()); DiscoveryServiceFilter filter = new DiscoveryServiceFilter(probe); // Check whether the inactive services should be skipped when searching AxisConfiguration axisConfig; String tenantDomain = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain(true); ConfigurationContext mainCfgCtx = ConfigHolder.getInstance().getServerConfigurationContext(); if (tenantDomain != MultitenantConstants.SUPER_TENANT_DOMAIN_NAME) { axisConfig = TenantAxisUtils.getTenantAxisConfiguration(tenantDomain, mainCfgCtx); } else { axisConfig = mainCfgCtx.getAxisConfiguration(); } Parameter parameter = axisConfig.getParameter(DiscoveryConstants.SKIP_INACTIVE_SERVICES); filter.setSkipInactiveServices(parameter == null || "true".equals(parameter.getValue())); Service[] services = serviceManager.findServices(filter); if (services != null && services.length > 0) { TargetService[] targetServices = new TargetService[services.length]; for (int i = 0; i < services.length; i++) { targetServices[i] = getTargetService(services[i]); } return targetServices; } return null; }
public void testParameterEdit() throws Exception { ConfigurationContext configCtx = ConfigurationContextFactory.createEmptyConfigurationContext(); AxisConfiguration axisConfig = configCtx.getAxisConfiguration(); Parameter parameter = new Parameter(); parameter.setValue("true"); parameter.setName("enableMTOM"); axisConfig.addParameter(parameter); parameter.setValue("true"); AxisServiceGroup serviceGroup = new AxisServiceGroupImpl(); serviceGroup.setName("testServiceGroup"); AxisService service = new AxisService(); service.setName("service"); serviceGroup.addService(service); axisConfig.addServiceGroup(serviceGroup); parameter = serviceGroup.getParameter("enableMTOM"); parameter.setValue("true"); Parameter para2 = serviceGroup.getParameter("enableMTOM"); assertEquals(para2.getValue(), "true"); Parameter test = new Parameter(); test.setName("test"); test.setValue("test"); serviceGroup.addParameter(test); Parameter para = serviceGroup.getParameter("test"); assertNotNull(para); assertEquals(para.getValue(), "test"); para.setValue("newValue"); para = serviceGroup.getParameter("test"); assertNotNull(para); assertEquals(para.getValue(), "newValue"); }
public void init(SynapseEnvironment synapseEnvironment) { ConfigurationContext cc = ((Axis2SynapseEnvironment) synapseEnvironment).getAxis2ConfigurationContext(); if (!initialized) { // The check for clustering environment ClusteringAgent clusteringAgent = cc.getAxisConfiguration().getClusteringAgent(); if (clusteringAgent != null && clusteringAgent.getStateManager() != null) { isClusteringEnabled = Boolean.TRUE; } else { isClusteringEnabled = Boolean.FALSE; } context = new EndpointContext(getName(), getDefinition(), isClusteringEnabled, cc, metricsMBean); } initialized = true; if (children != null) { for (Endpoint e : children) { e.init(synapseEnvironment); } } contentAware = definition != null && ((definition.getFormat() != null && !definition.getFormat().equals(SynapseConstants.FORMAT_REST)) || definition.isSecurityOn() || definition.isReliableMessagingOn() || definition.isAddressingOn() || definition.isUseMTOM() || definition.isUseSwa()); }
public void terminatingConfigurationContext(ConfigurationContext configurationContext) { String tenantDomain = SuperTenantCarbonContext.getCurrentContext(configurationContext).getTenantDomain(); log.info("Shutting down the persistence manager for the tenant: " + tenantDomain); Parameter p = configurationContext .getAxisConfiguration() .getParameter(ServiceBusConstants.PERSISTENCE_MANAGER); if (p != null && p.getValue() instanceof MediationPersistenceManager) { ((MediationPersistenceManager) p.getValue()).destroy(); } // unregister the service so that components get to know about the tenant termination int tenantId = SuperTenantCarbonContext.getCurrentContext(configurationContext).getTenantId(); ServiceRegistration tenantRegistration = ConfigurationHolder.getInstance().getSynapseRegistration(tenantId); if (tenantRegistration != null) { ConfigurationHolder.getInstance() .getBundleContext() .ungetService(tenantRegistration.getReference()); } }
/** * Set the transports for the tenants * * @param mainConfigCtx The main config context * @throws AxisFault If an error occurs while initializing tenant transports */ @SuppressWarnings("unchecked") public static void initializeTenantTransports(ConfigurationContext mainConfigCtx) throws AxisFault { AxisConfiguration mainAxisConfig = mainConfigCtx.getAxisConfiguration(); Map<String, ConfigurationContext> tenantConfigContexts = getTenantConfigurationContexts(mainConfigCtx); if (tenantConfigContexts != null) { for (Map.Entry<String, ConfigurationContext> entry : tenantConfigContexts.entrySet()) { String tenantDomain = entry.getKey(); ConfigurationContext tenantConfigCtx = entry.getValue(); AxisConfiguration tenantAxisConfig = tenantConfigCtx.getAxisConfiguration(); // Add the transports that are made available in the main axis2.xml file setTenantTransports(mainAxisConfig, tenantDomain, tenantAxisConfig); } } }
private void notifyClusterDSChange(String dsName) throws DataSourceException { if (log.isDebugEnabled()) { log.debug("Notifying cluster DS change: " + dsName); } ConfigurationContextService configCtxService = DataSourceServiceComponent.getConfigContextService(); if (configCtxService == null) { throw new DataSourceException( "ConfigurationContextService not available " + "for notifying the cluster"); } ConfigurationContext configCtx = configCtxService.getServerConfigContext(); ClusteringAgent agent = configCtx.getAxisConfiguration().getClusteringAgent(); if (log.isDebugEnabled()) { log.debug("Clustering Agent: " + agent); } if (agent != null) { DataSourceStatMessage msg = new DataSourceStatMessage(); msg.setTenantId(this.getTenantId()); msg.setDsName(dsName); try { agent.sendMessage(msg, true); } catch (ClusteringFault e) { throw new DataSourceException("Error in sending out cluster message: " + e.getMessage(), e); } } }
public static AxisConfiguration getTenantAxisConfiguration( String tenant, ConfigurationContext mainConfigCtx) { ConfigurationContext tenantConfigCtx = getTenantConfigurationContext(tenant, mainConfigCtx); if (tenantConfigCtx != null) { return tenantConfigCtx.getAxisConfiguration(); } return null; }
private String inferContentType() { Parameter param = cfgCtx.getAxisConfiguration().getParameter(NhttpConstants.REQUEST_CONTENT_TYPE); if (param != null) { return param.getValue().toString(); } return null; }
public static ServiceContext createAdressedEnabledClientSide(AxisService service) throws AxisFault { File file = getAddressingMARFile(); TestCase.assertTrue(file.exists()); ConfigurationContext configContext = ConfigurationContextFactory.createConfigurationContextFromFileSystem( "target/test-resources/integrationRepo", null); AxisModule axisModule = DeploymentEngine.buildModule(file, configContext.getAxisConfiguration()); AxisConfiguration axisConfiguration = configContext.getAxisConfiguration(); axisConfiguration.addModule(axisModule); axisConfiguration.addService(service); ServiceGroupContext serviceGroupContext = configContext.createServiceGroupContext((AxisServiceGroup) service.getParent()); return serviceGroupContext.getServiceContext(service); }
/** * Register a new ThreadContextMigrator. * * @param configurationContext * @param threadContextMigratorListID The name of the parameter in the AxisConfiguration that * contains the list of migrators. * @param migrator */ public static void addThreadContextMigrator( ConfigurationContext configurationContext, String threadContextMigratorListID, ThreadContextMigrator migrator) throws AxisFault { AxisConfiguration axisConfiguration = configurationContext.getAxisConfiguration(); addThreadContextMigrator(axisConfiguration, threadContextMigratorListID, migrator); }
/* Deploying CSV configuration */ public void processDeployStreamConfig(DeploymentFileData deploymentFileData) throws DeploymentException { CSVFileInfo csvFileInfo = DeploymentHelper.getCSVFileInfo( deploymentFileData.getFile(), configurationContext.getAxisConfiguration()); CarbonEventSimulator eventSimulator = EventSimulatorValueHolder.getEventSimulator(); eventSimulator.addCSVFileInfo(csvFileInfo); }
/** * Removes all Synapse proxy services from the Axis2 configuration. * * @throws AxisFault if an error occurs undeploying proxy services */ private void undeployProxyServices() throws AxisFault { log.info("Undeploying Proxy services..."); for (ProxyService proxy : synapseConfiguration.getProxyServices()) { configurationContext.getAxisConfiguration().removeService(proxy.getName()); } }
protected void setConfigurationContextService(ConfigurationContextService ccService) { ConfigurationContext serverCtx = ccService.getServerConfigContext(); AxisConfiguration serverConfig = serverCtx.getAxisConfiguration(); LocalTransportReceiver.CONFIG_CONTEXT = new ConfigurationContext(serverConfig); LocalTransportReceiver.CONFIG_CONTEXT.setServicePath("services"); LocalTransportReceiver.CONFIG_CONTEXT.setContextRoot("local:/"); Util.setConfigurationContextService(ccService); }
private void initPersistence( String configName, ConfigurationContext configurationContext, ServerContextInformation contextInfo) throws RegistryException, AxisFault { // Initialize the mediation persistence manager if required ServerConfiguration serverConf = ServerConfiguration.getInstance(); String persistence = serverConf.getFirstProperty(ServiceBusConstants.PERSISTENCE); org.wso2.carbon.registry.core.Registry configRegistry = (org.wso2.carbon.registry.core.Registry) SuperTenantCarbonContext.getCurrentContext(configurationContext) .getRegistry(RegistryType.SYSTEM_CONFIGURATION); // Check whether persistence is disabled if (!ServiceBusConstants.DISABLED.equals(persistence)) { // Check registry persistence is disabled or not String regPersistence = serverConf.getFirstProperty(ServiceBusConstants.REGISTRY_PERSISTENCE); UserRegistry registry = ServiceBusConstants.DISABLED.equals(regPersistence) ? null : (UserRegistry) configRegistry; // Check the worker interval is set or not String interval = serverConf.getFirstProperty(ServiceBusConstants.WORKER_INTERVAL); long intervalInMillis = 5000L; if (interval != null && !"".equals(interval)) { try { intervalInMillis = Long.parseLong(interval); } catch (NumberFormatException e) { log.error( "Invalid value " + interval + " specified for the mediation " + "persistence worker interval, Using defaults", e); } } MediationPersistenceManager pm = new MediationPersistenceManager( registry, contextInfo.getServerConfigurationInformation().getSynapseXMLLocation(), contextInfo.getSynapseConfiguration(), intervalInMillis, configName); configurationContext .getAxisConfiguration() .addParameter(new Parameter(ServiceBusConstants.PERSISTENCE_MANAGER, pm)); } else { log.info("Persistence for mediation configuration is disabled"); } }
/** Deploys the mediators in the mediator extensions folder. */ private void deployMediatorExtensions() { log.info("Loading mediator extensions..."); AxisConfigurator configurator = configurationContext.getAxisConfiguration().getConfigurator(); if (configurator instanceof DeploymentEngine) { ((DeploymentEngine) configurator).getRepoListener().checkServices(); } else { log.warn( "Unable to access the repository listener. Custom extensions will " + "not get loaded now!"); } }
/** Adds all Synapse proxy services to the Axis2 configuration. */ private void deployProxyServices() { boolean failSafeProxyEnabled = SynapseConfigUtils.isFailSafeEnabled(SynapseConstants.FAIL_SAFE_MODE_PROXY_SERVICES); log.info("Deploying Proxy services..."); String thisServerName = serverConfigurationInformation.getServerName(); if (thisServerName == null || "".equals(thisServerName)) { thisServerName = serverConfigurationInformation.getHostName(); if (thisServerName == null || "".equals(thisServerName)) { thisServerName = "localhost"; } } for (ProxyService proxy : synapseConfiguration.getProxyServices()) { // start proxy service if either, pinned server name list is empty // or pinned server list has this server name List pinnedServers = proxy.getPinnedServers(); if (pinnedServers != null && !pinnedServers.isEmpty()) { if (!pinnedServers.contains(thisServerName)) { log.info( "Server name not in pinned servers list." + " Not deploying Proxy service : " + proxy.getName()); continue; } } try { AxisService proxyService = proxy.buildAxisService( synapseConfiguration, configurationContext.getAxisConfiguration()); if (proxyService != null) { log.info("Deployed Proxy service : " + proxy.getName()); if (!proxy.isStartOnLoad()) { proxy.stop(synapseConfiguration); } } else { log.warn("The proxy service " + proxy.getName() + " will NOT be available"); } } catch (SynapseException e) { if (failSafeProxyEnabled) { log.warn( "The proxy service " + proxy.getName() + " cannot be deployed - " + "Continue in Proxy Service fail-safe mode."); } else { handleException("The proxy service " + proxy.getName() + " : Deployment Error"); } } } }
/** * The mediation library deployer will handling the process of deploying the libararyArtifacts, * this is required since the library specific artifacts has to be initialized priorly for the * cases like connectors */ private void deployMediationLibraryArtifacts() { if (configurationContext == null || synapseConfiguration == null) { return; } DeploymentEngine deploymentEngine = (DeploymentEngine) configurationContext.getAxisConfiguration().getConfigurator(); String carbonRepoPath = configurationContext.getAxisConfiguration().getRepository().getPath(); SynapseArtifactDeploymentStore deploymentStore = synapseConfiguration.getArtifactDeploymentStore(); String synapseImportDir = synapseConfiguration.getPathToConfigFile() + File.separator + MultiXMLConfigurationBuilder.SYNAPSE_IMPORTS_DIR; /*Registering Import Deployer is not required here.*/ // deploymentEngine.addDeployer(new ImportDeployer(), synapseImportDir, "xml"); String libsPath = carbonRepoPath + File.separator + "synapse-libs"; deploymentEngine.addDeployer(new LibraryArtifactDeployer(), libsPath, "zip"); }
public void uploadHumanTask(UploadedFileItem[] fileItems) throws AxisFault { // First lets filter for jar resources ConfigurationContext configurationContext = getConfigContext(); String repo = configurationContext.getAxisConfiguration().getRepository().getPath(); if (CarbonUtils.isURL(repo)) { throw new AxisFault("URL Repositories are not supported: " + repo); } // Writting the artifacts to the proper location String humantaskDirectory = getHumanTaskLocation(repo); String humantaskTemp = CarbonUtils.getCarbonHome() + File.separator + HumanTaskConstants.HUMANTASK_PACKAGE_TEMP_DIRECTORY; File humantaskTempDir = new File(humantaskTemp); if (!humantaskTempDir.exists() && !humantaskTempDir.mkdirs()) { throw new AxisFault("Fail to create the directory: " + humantaskTempDir.getAbsolutePath()); } File humantaskDir = new File(humantaskDirectory); if (!humantaskDir.exists() && !humantaskDir.mkdirs()) { throw new AxisFault("Fail to create the directory: " + humantaskDir.getAbsolutePath()); } for (UploadedFileItem uploadedFile : fileItems) { String fileName = uploadedFile.getFileName(); if (fileName == null || fileName.equals("")) { throw new AxisFault("Invalid file name. File name is not available"); } if (HumanTaskConstants.HUMANTASK_PACKAGE_EXTENSION.equals(uploadedFile.getFileType())) { try { writeResource(uploadedFile.getDataHandler(), humantaskTemp, fileName, humantaskDir); } catch (IOException e) { throw new AxisFault("IOError: Writing resource failed.", e); } } else { throw new AxisFault( "Invalid file type : " + uploadedFile.getFileType() + " ." + HumanTaskConstants.HUMANTASK_PACKAGE_EXTENSION + " file type is expected"); } } }
public void replicate(String key, ConcurrentAccessController concurrentAccessController) { try { ClusteringAgent clusteringAgent = configContext.getAxisConfiguration().getClusteringAgent(); if (clusteringAgent != null) { if (log.isDebugEnabled()) { log.debug("Replicating ConcurrentAccessController " + key + " in a ClusterMessage."); } clusteringAgent.sendMessage( new ConcurrentAccessUpdateClusterMessage(key, concurrentAccessController), true); } } catch (ClusteringFault e) { if (log.isErrorEnabled()) { log.error("Could not replicate throttle data", e); } } }
public ConfigurationContext getClientCfgCtx() throws Exception { ConfigurationContext cfgCtx = ConfigurationContextFactory.createConfigurationContext(new CustomAxisConfigurator()); AxisConfiguration axisCfg = cfgCtx.getAxisConfiguration(); axisCfg.engageModule("addressing"); TransportInDescription trpInDesc = new TransportInDescription("udp"); trpInDesc.setReceiver(new UDPListener()); axisCfg.addTransportIn(trpInDesc); TransportOutDescription trpOutDesc = new TransportOutDescription("udp"); trpOutDesc.setSender(new UDPSender()); axisCfg.addTransportOut(trpOutDesc); return cfgCtx; }
/** * Terminate the provided Tenant ConfigurationContext * * @param tenantCfgCtx The tenant ConfigurationContext which needs to be terminated */ public static void terminateTenantConfigContext(ConfigurationContext tenantCfgCtx) { ConfigurationContext mainServerConfigContext = CarbonCoreDataHolder.getInstance().getMainServerConfigContext(); Map<String, ConfigurationContext> tenantConfigContexts = getTenantConfigurationContexts(mainServerConfigContext); String tenantDomain = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantDomain(); log.info("Starting to clean tenant : " + tenantDomain); tenantCfgCtx.getAxisConfiguration().getConfigurator().cleanup(); try { doPreConfigContextTermination(tenantCfgCtx); tenantCfgCtx.terminate(); doPostConfigContextTermination(tenantCfgCtx); tenantConfigContexts.remove(tenantDomain); log.info("Cleaned up tenant " + tenantDomain); } catch (AxisFault e) { log.error("Cannot cleanup ConfigurationContext of tenant " + tenantDomain, e); } }
public boolean doThrottle( HttpServletRequest request, APIKeyValidationInfoDTO apiKeyValidationInfoDTO, String accessToken) { ThrottleManager throttleManager = new ThrottleManager(id, key); ConfigurationContext cc = DataHolder.getServerConfigContext(); ClusteringAgent clusteringAgent = cc.getAxisConfiguration().getClusteringAgent(); if (clusteringAgent != null && clusteringAgent.getStateManager() != null) { isClusteringEnable = true; } // check the availability of the ConcurrentAccessController // if this is a clustered environment if (isClusteringEnable) { concurrentAccessController = (ConcurrentAccessController) cc.getProperty(key); } initThrottle(cc); // perform concurrency throttling boolean canAccess = throttleManager.doThrottleByConcurrency(false, concurrentAccessController); if (canAccess) { String remoteIP = request.getRemoteAddr(); canAccess = throttleManager.throttleByAccessRate( remoteIP, remoteIP, cc, isClusteringEnable, concurrentAccessController, throttle) && throttleManager.doRoleBasedAccessThrottling( isClusteringEnable, cc, apiKeyValidationInfoDTO, accessToken, throttle); } // All the replication functionality of the access rate based throttling handled by itself // Just replicate the current state of ConcurrentAccessController if (isClusteringEnable && concurrentAccessController != null) { if (cc != null) { try { Replicator.replicate(cc); } catch (ClusteringFault clusteringFault) { handleException("Error during the replicating states ", clusteringFault); } } } if (!canAccess) { return false; } return true; }
/** * Adds Synapse Service to Axis2 configuration which enables the main message mediation. * * @throws AxisFault if an error occurs during Axis2 service initialization */ private void deploySynapseService() throws AxisFault { log.info("Deploying the Synapse service..."); // Dynamically initialize the Synapse Service and deploy it into Axis2 AxisConfiguration axisCfg = configurationContext.getAxisConfiguration(); AxisService synapseService = new AxisService(SynapseConstants.SYNAPSE_SERVICE_NAME); AxisOperation mediateOperation = new InOutAxisOperation(SynapseConstants.SYNAPSE_OPERATION_NAME); mediateOperation.setMessageReceiver(new SynapseMessageReceiver()); synapseService.addOperation(mediateOperation); List<String> transports = new ArrayList<String>(); transports.add(Constants.TRANSPORT_HTTP); transports.add(Constants.TRANSPORT_HTTPS); synapseService.setExposedTransports(transports); AxisServiceGroup synapseServiceGroup = new AxisServiceGroup(axisCfg); synapseServiceGroup.setServiceGroupName(SynapseConstants.SYNAPSE_SERVICE_NAME); synapseServiceGroup.addParameter(SynapseConstants.HIDDEN_SERVICE_PARAM, "true"); synapseServiceGroup.addService(synapseService); axisCfg.addServiceGroup(synapseServiceGroup); }
protected void activate(ComponentContext ctxt) { try { BundleContext bundleContext = ctxt.getBundleContext(); // registering ServiceUnloader as an OSGi service ServiceUnloader serviceUnloader = new ServiceUnloader(); bundleContext.registerService(ArtifactUnloader.class.getName(), serviceUnloader, null); if (serviceAdmin != null) { serviceAdmin.setConfigurationContext(configCtx); } try { // Registering ServiceAdmin as an OSGi service ServiceAdmin serviceAdmin = new ServiceAdmin(configCtx.getAxisConfiguration()); bundleContext.registerService(ServiceAdmin.class.getName(), serviceAdmin, null); } catch (Exception exception) { String msg = "An error occured while initializing ServiceAdmin as an OSGi Service"; log.error(msg, exception); } } catch (Throwable e) { log.error("Failed to activate the ServiceManagementServiceComponent", e); } }
@Override public void init(ConfigurationContext cfgCtx, TransportInDescription transportIn) throws AxisFault { super.init(cfgCtx, transportIn); DatagramDispatcherCallback callback = new DatagramDispatcherCallback() { public void receive(DatagramEndpoint endpoint, byte[] data, int length) { workerPool.execute(new ProcessPacketTask(endpoint, data, length)); } }; try { dispatcher = createDispatcher(callback); } catch (IOException ex) { throw new AxisFault("Unable to create selector", ex); } try { defaultIp = org.apache.axis2.util.Utils.getIpAddress(cfgCtx.getAxisConfiguration()); } catch (SocketException ex) { throw new AxisFault("Unable to determine the host's IP address", ex); } }