/** {@inheritDoc} */ public InvocationResponse invoke(MessageContext messageContext) throws AxisFault { if (log.isDebugEnabled()) { log.debug( "Starting Activation Handler invocation. Incoming Message: " + messageContext.getEnvelope().toString()); } AxisService service = messageContext.getAxisService(); int tenantId = getTenantId(messageContext); if (service != null && "ActivationService".equals(service.getName())) { log.debug("Granted access to the Activation Service"); if (tenantId > 0) { TenantAxisUtils.getTenantAxisConfiguration( getTenantDomain(), messageContext.getConfigurationContext()); log.debug("Loaded Tenant Configuration"); } return InvocationResponse.CONTINUE; } if (tenantId == MultitenantConstants.SUPER_TENANT_ID) { log.debug("Granted access for super tenant"); return InvocationResponse.CONTINUE; } if (ActivationManager.activationRecorded(tenantId)) { if (ActivationManager.getActivation(tenantId)) { TenantAxisUtils.getTenantAxisConfiguration( getTenantDomain(), messageContext.getConfigurationContext()); log.debug("Loaded Tenant Configuration"); return InvocationResponse.CONTINUE; } else { if (log.isWarnEnabled()) { String serviceName = Util.getServiceName(); log.warn("Failed attempt to access " + serviceName + " by tenant " + tenantId); } return InvocationResponse.ABORT; } } String serviceName = Util.getServiceName(); try { if (CloudServicesUtil.isCloudServiceActive(serviceName, tenantId)) { log.debug("Successful attempt to access " + serviceName + " by tenant " + tenantId); ActivationManager.setActivation(tenantId, true); TenantAxisUtils.getTenantAxisConfiguration( getTenantDomain(), messageContext.getConfigurationContext()); log.debug("Loaded Tenant Configuration"); return InvocationResponse.CONTINUE; } } catch (Exception e) { throw new AxisFault("Failed to determine Activation status.", e); } log.warn("Failed attempt to access " + serviceName + " by tenant " + tenantId); ActivationManager.setActivation(tenantId, false); return InvocationResponse.ABORT; }
public void run() { try { TenantAxisUtils.cleanupTenants(tenantIdleTimeMillis); } catch (Throwable e) { log.error("Error occurred while executing tenant cleanup", e); } }
/** * 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; }
/** * First create a Deployment engine, use that to create an AxisConfiguration * * @return Axis Configuration * @throws AxisFault */ public AxisConfiguration getAxisConfiguration() throws AxisFault { // ClassLoader origTccl = Thread.currentThread().getContextClassLoader(); // Thread.currentThread().setContextClassLoader(getClass().getClassLoader()); log.info( "Creating tenant AxisConfiguration for tenant: " + getTenantString(tenantDomain, tenantId)); PrivilegedCarbonContext.startTenantFlow(); try { PrivilegedCarbonContext carbonContext = PrivilegedCarbonContext.getCurrentContext(); carbonContext.setTenantId(tenantId); carbonContext.setTenantDomain(tenantDomain); if (log.isDebugEnabled()) { log.debug("Axis2 repo: " + repoLocation); } populateAxisConfig(); addDeployer(new ModuleDeployer(), repoLocation + File.separator + "axis2modules", "mar"); axisConfig.setConfigurator(this); // TODO: May need to set certain parameters into the AxisConfig // Hot deployment & update should be turned on for tenants axisConfig.addParameter(new Parameter(DeploymentConstants.TAG_HOT_DEPLOYMENT, "true")); axisConfig.addParameter(new Parameter(DeploymentConstants.TAG_HOT_UPDATE, "true")); globallyEngagedModules = axisConfig.getEngagedModules(); loadRepository(repoLocation); // set the service class loader in the axisConfig, this is needed due to ghost deployer // as the service deployer is no longer treated as a special case, we have to do this File axis2ServicesDir = new File(repoLocation, CarbonUtils.getAxis2ServicesDir(axisConfig)); if (axis2ServicesDir.exists()) { axisConfig.setServiceClassLoader( Utils.getClassLoader( axisConfig.getSystemClassLoader(), axis2ServicesDir, axisConfig.isChildFirstClassLoading())); } for (Object globallyEngagedModule : globallyEngagedModules) { AxisModule module = (AxisModule) globallyEngagedModule; if (log.isDebugEnabled()) { log.debug("Globally engaging module: " + module.getName()); } } // Remove all the transports made available in the tenant's axis2.xml axisConfig.getTransportsOut().clear(); // Remove all in-transports made available in the tenant's axis2.xml axisConfig.getTransportsIn().clear(); // Add the transports that are made available in the main axis2.xml file TenantAxisUtils.setTenantTransports(mainAxisConfig, tenantDomain, axisConfig); } finally { PrivilegedCarbonContext.endTenantFlow(); // Thread.currentThread().setContextClassLoader(origTccl); } return axisConfig; }
private static Registry getRegistry() throws DiscoveryException { String domain = CarbonContext.getThreadLocalCarbonContext().getTenantDomain(); if (domain != MultitenantConstants.SUPER_TENANT_DOMAIN_NAME) { AxisConfiguration axisConfig = TenantAxisUtils.getTenantAxisConfiguration( domain, ConfigHolder.getInstance().getServerConfigurationContext()); return (Registry) PrivilegedCarbonContext.getCurrentContext(axisConfig) .getRegistry(RegistryType.SYSTEM_GOVERNANCE); } return (Registry) PrivilegedCarbonContext.getCurrentContext().getRegistry(RegistryType.SYSTEM_GOVERNANCE); }
public void process( HttpRequest request, HttpResponse response, MessageContext messageContext, NHttpServerConnection conn, OutputStream outputStream, boolean b) { boolean isRequestHandled = false; String uri = request.getRequestLine().getUri(); String servicePath = cfgCtx.getServiceContextPath(); if (!servicePath.startsWith("/")) { servicePath = "/" + servicePath; } String serviceName = getServiceName(request); boolean loadBalancer = Boolean.parseBoolean(System.getProperty("wso2.loadbalancer", "false")); if (uri.equals("/favicon.ico")) { response.setStatusCode(HttpStatus.SC_MOVED_PERMANENTLY); response.addHeader("Location", "http://wso2.org/favicon.ico"); serverHandler.commitResponseHideExceptions(conn, response); isRequestHandled = true; } else if (uri.startsWith(servicePath) && (serviceName == null || serviceName.length() == 0)) { // check if service listing request is blocked if (isServiceListBlocked(uri)) { response.setStatusCode(HttpStatus.SC_FORBIDDEN); serverHandler.commitResponseHideExceptions(conn, response); } else { generateServicesList(response, conn, outputStream, servicePath); } try { outputStream.flush(); outputStream.close(); } catch (IOException ignore) { } isRequestHandled = true; } else { int pos = uri.indexOf('?'); if (pos != -1) { String queryString = uri.substring(pos + 1); String requestUri = uri.substring(0, pos); String requestUrl = uri; if (requestUri.indexOf("://") == -1) { HttpInetConnection inetConn = (HttpInetConnection) conn; String hostName = "localhost"; ServerConfiguration serverConfig = ServerConfiguration.getInstance(); if (serverConfig.getFirstProperty("HostName") != null) { hostName = serverConfig.getFirstProperty("HostName"); } requestUrl = "http://" + hostName + ":" + inetConn.getLocalPort() + requestUri; } String contextPath = cfgCtx.getServiceContextPath(); int beginIndex = -1; if (requestUri.indexOf(contextPath) != -1) { beginIndex = requestUri.indexOf(contextPath) + contextPath.length() + 1; } /** * This reverseProxyMode was introduce to avoid LB exposing it's own services when invoked * through rest call. For a soap call this works well. But for a rest call this does not * work as intended. in LB it has to set system property "reverseProxyMode" */ boolean reverseProxyMode = Boolean.parseBoolean(System.getProperty("reverseProxyMode")); AxisService axisService = null; if (!reverseProxyMode) { if (!(beginIndex < 0 || beginIndex > requestUri.length())) { serviceName = requestUri.substring(beginIndex); axisService = cfgCtx.getAxisConfiguration().getServiceForActivation(serviceName); } if (axisService == null && !loadBalancer && serviceName != null) { // Try to see whether the service is available in a tenant try { axisService = TenantAxisUtils.getAxisService(serviceName, cfgCtx); } catch (AxisFault axisFault) { axisFault.printStackTrace(); } } } if (queryString != null) { for (String item : getRequestProcessors.keySet()) { if (queryString.indexOf(item) == 0 && (queryString.equals(item) || queryString.indexOf("&") == item.length() || queryString.indexOf("=") == item.length())) { if (axisService == null) { continue; } try { processWithGetProcessor( request, response, requestUri, requestUrl, queryString, item, outputStream, conn); } catch (Exception e) { handleBrowserException(response, conn, outputStream, "Error processing request", e); } isRequestHandled = true; break; } } } } } if (!isRequestHandled) { processGetAndDelete(request, response, messageContext, conn, outputStream, "GET", b); } }