Merge pull request #204 from ayyoob/merge-latest

Merged device type multitenant implementation.
revert-70aa11f8
Prabath Abeysekara 9 years ago
commit f1081f7029

@ -1,5 +1,25 @@
<?xml version="1.0" encoding="UTF-8"?> <?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <!--
~ Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
~
~ WSO2 Inc. licenses this file to you under the Apache License,
~ Version 2.0 (the "License"); you may not use this file except
~ in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent> <parent>
<artifactId>apimgt-extensions</artifactId> <artifactId>apimgt-extensions</artifactId>
@ -61,6 +81,30 @@
<groupId>org.apache.axis2.wso2</groupId> <groupId>org.apache.axis2.wso2</groupId>
<artifactId>axis2</artifactId> <artifactId>axis2</artifactId>
</dependency> </dependency>
<dependency>
<groupId>com.google.code.gson</groupId>
<artifactId>gson</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.orbit.org.scannotation</groupId>
<artifactId>scannotation</artifactId>
</dependency>
<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>jsr311-api</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.apimgt.annotations</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.governance</groupId>
<artifactId>org.wso2.carbon.governance.api</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.governance</groupId>
<artifactId>org.wso2.carbon.governance.lcm</artifactId>
</dependency>
</dependencies> </dependencies>
@ -81,7 +125,8 @@
<Bundle-Name>${project.artifactId}</Bundle-Name> <Bundle-Name>${project.artifactId}</Bundle-Name>
<Bundle-Version>${carbon.device.mgt.version}</Bundle-Version> <Bundle-Version>${carbon.device.mgt.version}</Bundle-Version>
<Bundle-Description>API Management Webapp Publisher</Bundle-Description> <Bundle-Description>API Management Webapp Publisher</Bundle-Description>
<Private-Package>org.wso2.carbon.apimgt.webapp.publisher.internal</Private-Package> <Private-Package>org.wso2.carbon.apimgt.webapp.publisher.internal
</Private-Package>
<Export-Package> <Export-Package>
!org.wso2.carbon.apimgt.webapp.publisher.internal, !org.wso2.carbon.apimgt.webapp.publisher.internal,
org.wso2.carbon.apimgt.webapp.publisher.* org.wso2.carbon.apimgt.webapp.publisher.*
@ -91,7 +136,8 @@
org.osgi.service.component, org.osgi.service.component,
org.apache.commons.logging, org.apache.commons.logging,
javax.servlet, javax.servlet,
javax.xml.bind.annotation, javax.xml.*,
com.google.gson.*,
org.apache.catalina, org.apache.catalina,
org.apache.catalina.core, org.apache.catalina.core,
org.wso2.carbon.apimgt.api, org.wso2.carbon.apimgt.api,
@ -99,12 +145,20 @@
org.wso2.carbon.apimgt.impl, org.wso2.carbon.apimgt.impl,
org.apache.axis2.*;version="${axis2.osgi.version.range}", org.apache.axis2.*;version="${axis2.osgi.version.range}",
org.wso2.carbon.core, org.wso2.carbon.core,
org.wso2.carbon.utils org.apache.commons.lang,
org.wso2.carbon.utils,
org.wso2.carbon.apimgt.annotations.*,
org.wso2.carbon.governance.lcm.util.*,
org.wso2.carbon.registry.core.*
</Import-Package> </Import-Package>
<Embed-Dependency>
scribe;scope=compile|runtime;inline=false;
</Embed-Dependency>
<DynamicImport-Package>*</DynamicImport-Package>
</instructions> </instructions>
</configuration> </configuration>
</plugin> </plugin>
</plugins> </plugins>
</build> </build>
</project> </project>

@ -20,11 +20,16 @@ package org.wso2.carbon.apimgt.webapp.publisher;
import org.wso2.carbon.apimgt.api.APIManagementException; import org.wso2.carbon.apimgt.api.APIManagementException;
import org.wso2.carbon.apimgt.api.APIProvider; import org.wso2.carbon.apimgt.api.APIProvider;
import org.wso2.carbon.apimgt.api.model.URITemplate;
import org.wso2.carbon.apimgt.impl.APIConstants;
import org.wso2.carbon.apimgt.impl.APIManagerFactory; import org.wso2.carbon.apimgt.impl.APIManagerFactory;
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
import javax.xml.bind.annotation.XmlElement; import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlRootElement;
import javax.xml.bind.annotation.XmlTransient; import javax.xml.bind.annotation.XmlTransient;
import java.util.List;
import java.util.Set;
/** /**
* This bean class carries the properties used by some API that needs to be published within the underlying * This bean class carries the properties used by some API that needs to be published within the underlying
@ -48,20 +53,35 @@ public class APIConfig {
private String name; private String name;
private String owner; private String owner;
private String context; private String context;
private String contextTemplate;
private String endpoint; private String endpoint;
private String version; private String version;
private String transports; private String transports;
private APIProvider provider; private APIProvider provider;
private boolean isSecured; private boolean isSecured;
private Set<URITemplate> uriTemplates;
private List<String> tenants;
private boolean isSharedWithAllTenants;
private String tenantDomain;
private String[] tags;
public void init() throws APIManagementException { public void init() throws APIManagementException {
try { try {
this.provider = APIManagerFactory.getInstance().getAPIProvider(this.getOwner()); this.provider = APIManagerFactory.getInstance().getAPIProvider(owner);
} catch (APIManagementException e) { } catch (APIManagementException e) {
throw new APIManagementException("Error occurred while initializing API provider", e); throw new APIManagementException("Error occurred while initializing API provider", e);
} }
} }
@XmlElement(name = "ContextTemplate", required = true)
public String getContextTemplate() {
return contextTemplate;
}
public void setContextTemplate(String contextTemplate) {
this.contextTemplate = contextTemplate;
}
@XmlTransient @XmlTransient
public APIProvider getProvider() { public APIProvider getProvider() {
return provider; return provider;
@ -136,4 +156,43 @@ public class APIConfig {
isSecured = secured; isSecured = secured;
} }
@XmlElement(name = "UriTemplates", required = false)
public Set<URITemplate> getUriTemplates() {
return uriTemplates;
}
@SuppressWarnings("unused")
public void setUriTemplates(Set<URITemplate> uriTemplates) {
this.uriTemplates = uriTemplates;
}
@XmlElement(name = "isSharedWithAllTenants", required = false)
public boolean isSharedWithAllTenants() {
return isSharedWithAllTenants;
}
@SuppressWarnings("unused")
public void setSharedWithAllTenants(boolean isSharedWithAllTenants) {
this.isSharedWithAllTenants = isSharedWithAllTenants;
}
@XmlElement(name = "tenantDomain", required = false)
public String getTenantDomain() {
return tenantDomain;
}
@SuppressWarnings("unused")
public void setTenantDomain(String tenantDomain) {
this.tenantDomain = tenantDomain;
}
@XmlElement(name = "tags", required = false)
public String[] getTags() {
return tags;
}
@SuppressWarnings("unused")
public void setTags(String[] tags) {
this.tags = tags;
}
} }

@ -19,9 +19,9 @@
package org.wso2.carbon.apimgt.webapp.publisher; package org.wso2.carbon.apimgt.webapp.publisher;
import org.wso2.carbon.apimgt.api.APIManagementException; import org.wso2.carbon.apimgt.api.APIManagementException;
import org.wso2.carbon.apimgt.api.FaultGatewaysException;
import org.wso2.carbon.apimgt.api.model.API; import org.wso2.carbon.apimgt.api.model.API;
import org.wso2.carbon.apimgt.api.model.APIIdentifier; import org.wso2.carbon.apimgt.api.model.APIIdentifier;
import java.util.List; import java.util.List;
/** /**
@ -39,7 +39,7 @@ public interface APIPublisherService {
* @param api An instance of the bean that passes metadata related to the API being published * @param api An instance of the bean that passes metadata related to the API being published
* @throws APIManagementException Is thrown if some unexpected event occurs while publishing the API * @throws APIManagementException Is thrown if some unexpected event occurs while publishing the API
*/ */
void publishAPI(API api) throws APIManagementException; void publishAPI(API api) throws APIManagementException, FaultGatewaysException;
/** /**
* This method removes an API that's already published within the underlying API-Management infrastructure. * This method removes an API that's already published within the underlying API-Management infrastructure.
@ -55,6 +55,5 @@ public interface APIPublisherService {
* @param apis A list of the beans that passes metadata related to the APIs being published * @param apis A list of the beans that passes metadata related to the APIs being published
* @throws APIManagementException Is thrown if some unexpected event occurs while publishing the APIs * @throws APIManagementException Is thrown if some unexpected event occurs while publishing the APIs
*/ */
void publishAPIs(List<API> apis) throws APIManagementException; void publishAPIs(List<API> apis) throws APIManagementException, FaultGatewaysException;
} }

@ -18,6 +18,7 @@
*/ */
package org.wso2.carbon.apimgt.webapp.publisher; package org.wso2.carbon.apimgt.webapp.publisher;
import com.google.gson.JsonObject;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.apimgt.api.APIManagementException; import org.wso2.carbon.apimgt.api.APIManagementException;
@ -25,8 +26,17 @@ import org.wso2.carbon.apimgt.api.APIProvider;
import org.wso2.carbon.apimgt.api.FaultGatewaysException; import org.wso2.carbon.apimgt.api.FaultGatewaysException;
import org.wso2.carbon.apimgt.api.model.API; import org.wso2.carbon.apimgt.api.model.API;
import org.wso2.carbon.apimgt.api.model.APIIdentifier; import org.wso2.carbon.apimgt.api.model.APIIdentifier;
import org.wso2.carbon.apimgt.api.model.URITemplate;
import org.wso2.carbon.apimgt.impl.APIManagerFactory; import org.wso2.carbon.apimgt.impl.APIManagerFactory;
import org.wso2.carbon.apimgt.webapp.publisher.internal.APIPublisherDataHolder;
import org.wso2.carbon.governance.lcm.util.CommonUtil;
import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
import javax.xml.stream.XMLStreamException;
import java.io.FileNotFoundException;
import java.util.List; import java.util.List;
/** /**
@ -38,33 +48,82 @@ public class APIPublisherServiceImpl implements APIPublisherService {
private static final Log log = LogFactory.getLog(APIPublisherServiceImpl.class); private static final Log log = LogFactory.getLog(APIPublisherServiceImpl.class);
@Override @Override
public void publishAPI(API api) throws APIManagementException { public void publishAPI(API api) throws APIManagementException, FaultGatewaysException {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Publishing API '" + api.getId() + "'"); log.debug("Publishing API '" + api.getId() + "'");
} }
APIProvider provider = APIManagerFactory.getInstance().getAPIProvider(api.getApiOwner()); try {
if (provider != null) { String tenantDomain = MultitenantUtils.getTenantDomain(api.getApiOwner());
if (!provider.isAPIAvailable(api.getId())) { int tenantId =
provider.addAPI(api); APIPublisherDataHolder.getInstance().getRealmService().getTenantManager().getTenantId(tenantDomain);
log.info("Successfully published API '" + api.getId().getApiName() + "' with context '" + // Below code snippet is added load API Lifecycle in tenant mode, where in it does not load when tenant is loaded.
api.getContext() + "' and version '" + api.getId().getVersion() + "'"); RegistryService registryService = APIPublisherDataHolder.getInstance().getRegistryService();
} else { CommonUtil.addDefaultLifecyclesIfNotAvailable(registryService.getConfigSystemRegistry(tenantId),
try { CommonUtil.getRootSystemRegistry(tenantId));
APIProvider provider = APIManagerFactory.getInstance().getAPIProvider(api.getApiOwner());
MultitenantUtils.getTenantDomain(api.getApiOwner());
if (provider != null) {
if (!provider.isAPIAvailable(api.getId())) {
provider.addAPI(api);
log.info("Successfully published API '" + api.getId().getApiName() + "' with context '" +
api.getContext() + "' and version '" + api.getId().getVersion() + "'");
} else {
provider.updateAPI(api); provider.updateAPI(api);
log.info("An API already exists with the name '" + api.getId().getApiName() + "', context '" + log.info("An API already exists with the name '" + api.getId().getApiName() + "', context '" +
api.getContext() + "' and version '" + api.getId().getVersion() + api.getContext() + "' and version '" + api.getId().getVersion() +
"'. Thus, the API config is updated"); "'. Thus, the API config is updated");
} catch (FaultGatewaysException e) {
throw new APIManagementException("Error occurred while updating API " + api.getId().getApiName() +
"' with context '" + api.getContext() + "' and version '" + api.getId().getVersion() + "'");
} }
provider.saveSwagger20Definition(api.getId(), createSwaggerDefinition(api));
} else {
throw new APIManagementException("API provider configured for the given API configuration is null. " +
"Thus, the API is not published");
} }
} else { } catch (UserStoreException e) {
throw new APIManagementException("API provider configured for the given API configuration is null. " + throw new APIManagementException("Failed to get the tenant id for the user " + api.getApiOwner(), e);
"Thus, the API is not published"); } catch (FileNotFoundException e) {
throw new APIManagementException("Failed to retrieve life cycle file ", e);
} catch (RegistryException e) {
throw new APIManagementException("Failed to access the registry ", e);
} catch (XMLStreamException e) {
throw new APIManagementException("Failed parsing the lifecycle xml.", e);
} }
} }
private String createSwaggerDefinition(API api) {
//{"paths":{"/controller/*":{"get":{"responses":{"200":{}}}},"/manager/*":{"get":{"responses":{"200":{}}}}},
// "swagger":"2.0","info":{"title":"RaspberryPi","version":"1.0.0"}}
JsonObject swaggerDefinition = new JsonObject();
JsonObject paths = new JsonObject();
for (URITemplate uriTemplate : api.getUriTemplates()) {
JsonObject response = new JsonObject();
response.addProperty("200", "");
JsonObject responses = new JsonObject();
responses.add("responses", response);
JsonObject httpVerb = new JsonObject();
httpVerb.add(uriTemplate.getHTTPVerb().toLowerCase(), responses);
JsonObject path = new JsonObject();
path.add(uriTemplate.getUriTemplate(), httpVerb);
paths.add(uriTemplate.getUriTemplate(), httpVerb);
}
swaggerDefinition.add("paths", paths);
swaggerDefinition.addProperty("swagger", "2.0");
JsonObject info = new JsonObject();
info.addProperty("title", api.getId().getApiName());
info.addProperty("version", api.getId().getVersion());
swaggerDefinition.add("info", info);
return swaggerDefinition.toString();
//return "{\"paths\":{\"/controller/*\":{\"get\":{\"responses\":{\"200\":{}}}},
// \"/manager/*\":{\"get\":{\"responses\":{\"200\":{}}}}},\"swagger\":\"2.0\",
// \"info\":{\"title\":\"RaspberryPi\",\"version\":\"1.0.0\"}}";
}
@Override @Override
public void removeAPI(APIIdentifier id) throws APIManagementException { public void removeAPI(APIIdentifier id) throws APIManagementException {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
@ -78,7 +137,7 @@ public class APIPublisherServiceImpl implements APIPublisherService {
} }
@Override @Override
public void publishAPIs(List<API> apis) throws APIManagementException { public void publishAPIs(List<API> apis) throws APIManagementException, FaultGatewaysException {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Publishing a batch of APIs"); log.debug("Publishing a batch of APIs");
} }
@ -93,5 +152,4 @@ public class APIPublisherServiceImpl implements APIPublisherService {
log.debug("End of publishing the batch of APIs"); log.debug("End of publishing the batch of APIs");
} }
} }
} }

@ -1,42 +1,43 @@
/* /*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved. * Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
* *
* WSO2 Inc. licenses this file to you under the Apache License, * WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except * Version 2.0 (the "License"); you may not use this file except
* in compliance with the License. * in compliance with the License.
* You may obtain a copy of the License at * You may obtain a copy of the License at
* *
* http://www.apache.org/licenses/LICENSE-2.0 * http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
* *
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/ */
package org.wso2.carbon.apimgt.webapp.publisher; package org.wso2.carbon.apimgt.webapp.publisher;
import org.wso2.carbon.apimgt.api.APIManagementException; import org.wso2.carbon.apimgt.api.APIManagementException;
import org.wso2.carbon.apimgt.api.APIProvider; import org.wso2.carbon.apimgt.api.APIProvider;
import org.wso2.carbon.apimgt.api.model.API; import org.wso2.carbon.apimgt.api.model.*;
import org.wso2.carbon.apimgt.api.model.APIIdentifier;
import org.wso2.carbon.apimgt.api.model.APIStatus;
import org.wso2.carbon.apimgt.api.model.URITemplate;
import org.wso2.carbon.apimgt.impl.APIConstants; import org.wso2.carbon.apimgt.impl.APIConstants;
import org.wso2.carbon.apimgt.webapp.publisher.internal.APIPublisherDataHolder; import org.wso2.carbon.apimgt.webapp.publisher.internal.APIPublisherDataHolder;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.user.api.TenantManager;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.utils.CarbonUtils; import org.wso2.carbon.utils.CarbonUtils;
import org.wso2.carbon.utils.ConfigurationContextService; import org.wso2.carbon.utils.ConfigurationContextService;
import org.wso2.carbon.utils.NetworkUtils; import org.wso2.carbon.utils.NetworkUtils;
import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
import java.util.ArrayList; import java.util.*;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
public class APIPublisherUtil { public class APIPublisherUtil {
private static final String DEFAULT_API_VERSION = "1.0.0";
public static final String API_VERSION_PARAM="{version}";
enum HTTPMethod { enum HTTPMethod {
GET, POST, DELETE, PUT, OPTIONS GET, POST, DELETE, PUT, OPTIONS
} }
@ -54,21 +55,53 @@ public class APIPublisherUtil {
public static API getAPI(APIConfig config) throws APIManagementException { public static API getAPI(APIConfig config) throws APIManagementException {
APIProvider provider = config.getProvider(); APIProvider provider = config.getProvider();
APIIdentifier id = new APIIdentifier(config.getOwner(), config.getName(), config.getVersion()); String apiVersion = config.getVersion();
APIIdentifier id = new APIIdentifier(replaceEmailDomain(config.getOwner()), config.getName(), apiVersion);
API api = new API(id); API api = new API(id);
api.setApiOwner(config.getOwner()); api.setApiOwner(config.getOwner());
api.setContext(config.getContext()); String context = config.getContext();
context = context.startsWith("/") ? context : ("/" + context);
String providerDomain = config.getTenantDomain();
if (!MultitenantConstants.SUPER_TENANT_DOMAIN_NAME.equalsIgnoreCase(providerDomain)) {
//Create tenant aware context for API
context = "/t/" + providerDomain + context;
}
// This is to support the new Pluggable version strategy
// if the context does not contain any {version} segment, we use the default version strategy.
context = checkAndSetVersionParam(context);
api.setContextTemplate(context);
context = updateContextWithVersion(config.getVersion(), context);
api.setContext(context);
api.setUrl(config.getEndpoint()); api.setUrl(config.getEndpoint());
api.setUriTemplates(
getURITemplates(config.getEndpoint(), APIConstants.AUTH_APPLICATION_OR_USER_LEVEL_TOKEN));
api.setVisibility(APIConstants.API_GLOBAL_VISIBILITY);
api.addAvailableTiers(provider.getTiers()); api.addAvailableTiers(provider.getTiers());
api.setEndpointSecured(true); api.setEndpointSecured(true);
api.setStatus(APIStatus.PUBLISHED); api.setStatus(APIStatus.PUBLISHED);
api.setTransports(config.getTransports()); api.setTransports(config.getTransports());
api.setAsDefaultVersion(true); api.setContextTemplate(config.getContextTemplate());
api.setAsPublishedDefaultVersion(true); api.setUriTemplates(config.getUriTemplates());
Set<Tier> tiers = new HashSet<Tier>();
tiers.add(new Tier(APIConstants.UNLIMITED_TIER));
api.addAvailableTiers(tiers);
if (config.isSharedWithAllTenants()) {
api.setSubscriptionAvailability(APIConstants.SUBSCRIPTION_TO_ALL_TENANTS);
api.setVisibility(APIConstants.API_GLOBAL_VISIBILITY);
} else {
api.setSubscriptionAvailability(APIConstants.SUBSCRIPTION_TO_CURRENT_TENANT);
api.setVisibility(APIConstants.API_PRIVATE_VISIBILITY);
}
api.setResponseCache(APIConstants.DISABLED);
String endpointConfig = "{\"production_endpoints\":{\"url\":\" " + config.getEndpoint() + "\",\"config\":null},\"endpoint_type\":\"http\"}";
api.setEndpointConfig(endpointConfig);
if ("".equals(id.getVersion()) || (DEFAULT_API_VERSION.equals(id.getVersion()))) {
api.setAsDefaultVersion(Boolean.TRUE);
api.setAsPublishedDefaultVersion(Boolean.TRUE);
}
if (config.getTags() != null && config.getTags().length > 0) {
Set<String> tags = new HashSet<>(Arrays.asList(config.getTags()));
api.addTags(tags);
}
return api; return api;
} }
@ -125,4 +158,35 @@ public class APIPublisherUtil {
return getServerBaseUrl() + context; return getServerBaseUrl() + context;
} }
/**
* When an input is having '@',replace it with '-AT-' [This is required to persist API data in registry,as registry paths don't allow '@' sign.]
* @param input inputString
* @return String modifiedString
*/
private static String replaceEmailDomain(String input){
if(input!=null&& input.contains(APIConstants.EMAIL_DOMAIN_SEPARATOR) ){
input=input.replace(APIConstants.EMAIL_DOMAIN_SEPARATOR,APIConstants.EMAIL_DOMAIN_SEPARATOR_REPLACEMENT);
}
return input;
}
private static String updateContextWithVersion(String version, String context) {
// This condition should not be true for any occasion but we keep it so that there are no loopholes in
// the flow.
context = context.replace(API_VERSION_PARAM, version);
return context;
}
private static String checkAndSetVersionParam(String context) {
// This is to support the new Pluggable version strategy
// if the context does not contain any {version} segment, we use the default version strategy.
if(!context.contains(API_VERSION_PARAM)){
if(!context.endsWith("/")){
context = context + "/";
}
context = context +API_VERSION_PARAM;
}
return context;
}
} }

@ -0,0 +1,87 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* you may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.apimgt.webapp.publisher.config;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
@XmlRootElement(name = "Resource")
public class APIResource{
private String AuthType;
private String HttpVerb;
private String Uri;
private String UriTemplate;
private String consumes;
private String produces;
public String getAuthType() {
return AuthType;
}
@XmlElement(name = "AuthType", required = true)
public void setAuthType(String authType) {
AuthType = authType;
}
public String getHttpVerb() {
return HttpVerb;
}
@XmlElement(name = "HttpVerb", required = true)
public void setHttpVerb(String httpVerb) {
HttpVerb = httpVerb;
}
public String getUri() {
return Uri;
}
@XmlElement(name = "Uri", required = true)
public void setUri(String uri) {
Uri = uri;
}
public String getUriTemplate() {
return UriTemplate;
}
@XmlElement(name = "UriTemplate", required = true)
public void setUriTemplate(String uriTemplate) {
UriTemplate = uriTemplate;
}
public String getConsumes() {
return consumes;
}
@XmlElement(name = "Consumes", required = true)
public void setConsumes(String consumes) {
this.consumes = consumes;
}
public String getProduces() {
return produces;
}
@XmlElement(name = "Produces", required = true)
public void setProduces(String produces) {
this.produces = produces;
}
}

@ -0,0 +1,79 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* you may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.apimgt.webapp.publisher.config;
import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement;
import java.util.List;
@XmlRootElement(name = "ResourceConfiguration")
public class APIResourceConfiguration {
private String name;
private String context;
private String version;
private List<APIResource> resources;
private String[] tags;
public List<APIResource> getResources() {
return resources;
}
@XmlElement(name = "Resources", required = true)
public void setResources(List<APIResource> resources) {
this.resources = resources;
}
public String getContext() {
return context;
}
@XmlElement(name = "Context", required = true)
public void setContext(String context) {
this.context = context;
}
public String getName() {
return name;
}
@XmlElement(name = "Name")
public void setName(String name) {
this.name = name;
}
public String getVersion() {
return version;
}
@XmlElement(name = "Version")
public void setVersion(String version) {
this.version = version;
}
public String[] getTags() {
return tags;
}
@XmlElement(name = "Tags")
public void setTags(String[] tags) {
this.tags = tags;
}
}

@ -0,0 +1,38 @@
package org.wso2.carbon.apimgt.webapp.publisher.config;
public class APIResourceManagementException extends Exception{
private static final long serialVersionUID = -3151279311929070297L;
private String errorMessage;
public String getErrorMessage() {
return errorMessage;
}
public void setErrorMessage(String errorMessage) {
this.errorMessage = errorMessage;
}
public APIResourceManagementException(String msg, Exception nestedEx) {
super(msg, nestedEx);
setErrorMessage(msg);
}
public APIResourceManagementException(String message, Throwable cause) {
super(message, cause);
setErrorMessage(message);
}
public APIResourceManagementException(String msg) {
super(msg);
setErrorMessage(msg);
}
public APIResourceManagementException() {
super();
}
public APIResourceManagementException(Throwable cause) {
super(cause);
}
}

@ -0,0 +1,69 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* you may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.apimgt.webapp.publisher.config;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import java.io.InputStream;
import java.util.List;
import java.util.Set;
/**
* This class will add, update custom permissions defined in resources.xml in webapps.
*/
public class APIResourceManager {
private static APIResourceManager resourceManager;
private List<APIResource> resourceList;
private APIResourceManager(){};
public static APIResourceManager getInstance() {
if (resourceManager == null) {
synchronized (APIResourceManager.class) {
if (resourceManager == null) {
resourceManager = new APIResourceManager();
}
}
}
return resourceManager;
}
public void initializeResources(InputStream resourceStream) throws APIResourceManagementException {
try {
if(resourceStream != null){
/* Un-marshaling Device Management configuration */
JAXBContext cdmContext = JAXBContext.newInstance(APIResourceConfiguration.class);
Unmarshaller unmarshaller = cdmContext.createUnmarshaller();
APIResourceConfiguration resourcesConfiguration = (APIResourceConfiguration)
unmarshaller.unmarshal(resourceStream);
if((resourcesConfiguration != null) && (resourcesConfiguration.getResources() != null)){
this.resourceList = resourcesConfiguration.getResources();
}
}
} catch (JAXBException e) {
throw new APIResourceManagementException("Error occurred while initializing Data Source config", e);
}
}
public List<APIResource> getAPIResources(){
return resourceList;
}
}

@ -18,13 +18,20 @@
*/ */
package org.wso2.carbon.apimgt.webapp.publisher.internal; package org.wso2.carbon.apimgt.webapp.publisher.internal;
import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherService; import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherService;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.user.core.service.RealmService;
import org.wso2.carbon.user.core.tenant.TenantManager;
import org.wso2.carbon.utils.ConfigurationContextService; import org.wso2.carbon.utils.ConfigurationContextService;
public class APIPublisherDataHolder { public class APIPublisherDataHolder {
private APIPublisherService apiPublisherService; private APIPublisherService apiPublisherService;
private ConfigurationContextService configurationContextService; private ConfigurationContextService configurationContextService;
private RealmService realmService;
private TenantManager tenantManager;
private RegistryService registryService;
private static APIPublisherDataHolder thisInstance = new APIPublisherDataHolder(); private static APIPublisherDataHolder thisInstance = new APIPublisherDataHolder();
@ -57,4 +64,34 @@ public class APIPublisherDataHolder {
return configurationContextService; return configurationContextService;
} }
public RealmService getRealmService() {
if (realmService == null) {
throw new IllegalStateException("Realm service is not initialized properly");
}
return realmService;
}
public void setRealmService(RealmService realmService) {
this.realmService = realmService;
this.setTenantManager(realmService);
}
private void setTenantManager(RealmService realmService) {
if (realmService == null) {
throw new IllegalStateException("Realm service is not initialized properly");
}
this.tenantManager = realmService.getTenantManager();
}
public TenantManager getTenantManager() {
return tenantManager;
}
public RegistryService getRegistryService() {
return registryService;
}
public void setRegistryService(RegistryService registryService) {
this.registryService = registryService;
}
} }

@ -25,6 +25,8 @@ import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.apimgt.impl.APIManagerConfigurationService; import org.wso2.carbon.apimgt.impl.APIManagerConfigurationService;
import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherService; import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherService;
import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherServiceImpl; import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherServiceImpl;
import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.user.core.service.RealmService;
import org.wso2.carbon.utils.ConfigurationContextService; import org.wso2.carbon.utils.ConfigurationContextService;
/** /**
@ -35,6 +37,18 @@ import org.wso2.carbon.utils.ConfigurationContextService;
* policy="dynamic" * policy="dynamic"
* bind="setConfigurationContextService" * bind="setConfigurationContextService"
* unbind="unsetConfigurationContextService" * unbind="unsetConfigurationContextService"
* @scr.reference name="user.realmservice.default"
* interface="org.wso2.carbon.user.core.service.RealmService"
* cardinality="1..1"
* policy="dynamic"
* bind="setRealmService"
* unbind="unsetRealmService"
* @scr.reference name="registry.service"
* interface="org.wso2.carbon.registry.core.service.RegistryService"
* cardinality="1..1"
* policy="dynamic"
* bind="setRegistryService"
* unbind="unsetRegistryService"
*/ */
public class APIPublisherServiceComponent { public class APIPublisherServiceComponent {
@ -95,4 +109,28 @@ public class APIPublisherServiceComponent {
APIPublisherDataHolder.getInstance().setConfigurationContextService(null); APIPublisherDataHolder.getInstance().setConfigurationContextService(null);
} }
protected void setRealmService(RealmService realmService) {
if (log.isDebugEnabled()) {
log.debug("Setting Realm Service");
}
APIPublisherDataHolder.getInstance().setRealmService(realmService);
}
protected void unsetRealmService(RealmService realmService) {
if (log.isDebugEnabled()) {
log.debug("Unsetting Realm Service");
}
APIPublisherDataHolder.getInstance().setRealmService(null);
}
protected void setRegistryService(RegistryService registryService) {
if (registryService != null && log.isDebugEnabled()) {
log.debug("Registry service initialized");
}
APIPublisherDataHolder.getInstance().setRegistryService(registryService);
}
protected void unsetRegistryService(RegistryService registryService) {
APIPublisherDataHolder.getInstance().setRegistryService(null);
}
} }

@ -24,135 +24,209 @@ import org.apache.catalina.LifecycleListener;
import org.apache.catalina.core.StandardContext; import org.apache.catalina.core.StandardContext;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.apimgt.api.model.API; import org.wso2.carbon.apimgt.api.model.*;
import org.wso2.carbon.apimgt.webapp.publisher.APIConfig; import org.wso2.carbon.apimgt.webapp.publisher.*;
import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherService; import org.wso2.carbon.apimgt.webapp.publisher.config.APIResource;
import org.wso2.carbon.apimgt.webapp.publisher.APIPublisherUtil; import org.wso2.carbon.apimgt.webapp.publisher.config.APIResourceConfiguration;
import org.wso2.carbon.apimgt.webapp.publisher.internal.APIPublisherDataHolder; import org.wso2.carbon.apimgt.webapp.publisher.internal.APIPublisherDataHolder;
import org.wso2.carbon.apimgt.webapp.publisher.lifecycle.util.AnnotationUtil;
import org.wso2.carbon.base.MultitenantConstants;
import javax.servlet.ServletContext; import javax.servlet.ServletContext;
import java.io.IOException;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Set;
@SuppressWarnings("unused") @SuppressWarnings("unused")
public class APIPublisherLifecycleListener implements LifecycleListener { public class APIPublisherLifecycleListener implements LifecycleListener {
private static final String API_CONFIG_DEFAULT_VERSION = "1.0.0"; private static final String API_CONFIG_DEFAULT_VERSION = "1.0.0";
private static final String PARAM_MANAGED_API_ENABLED = "managed-api-enabled"; private static final String PARAM_MANAGED_API_ENABLED = "managed-api-enabled";
private static final String PARAM_MANAGED_API_NAME = "managed-api-name"; private static final String PARAM_MANAGED_API_NAME = "managed-api-name";
private static final String PARAM_MANAGED_API_VERSION = "managed-api-version"; private static final String PARAM_MANAGED_API_VERSION = "managed-api-version";
private static final String PARAM_MANAGED_API_CONTEXT = "managed-api-context"; private static final String PARAM_MANAGED_API_CONTEXT = "managed-api-context";
private static final String PARAM_MANAGED_API_ENDPOINT = "managed-api-endpoint"; private static final String PARAM_MANAGED_API_ENDPOINT = "managed-api-endpoint";
private static final String PARAM_MANAGED_API_OWNER = "managed-api-owner"; private static final String PARAM_MANAGED_API_OWNER = "managed-api-owner";
private static final String PARAM_MANAGED_API_TRANSPORTS = "managed-api-transports"; private static final String PARAM_MANAGED_API_TRANSPORTS = "managed-api-transports";
private static final String PARAM_MANAGED_API_IS_SECURED = "managed-api-isSecured"; private static final String PARAM_MANAGED_API_IS_SECURED = "managed-api-isSecured";
private static final String PARAM_MANAGED_API_APPLICATION = "managed-api-application";
private static final Log log = LogFactory.getLog(APIPublisherLifecycleListener.class); private static final String PARAM_MANAGED_API_CONTEXT_TEMPLATE = "managed-api-context-template";
private static final String PARAM_SHARED_WITH_ALL_TENANTS = "isSharedWithAllTenants";
@Override private static final String PARAM_PROVIDER_TENANT_DOMAIN = "providerTenantDomain";
public void lifecycleEvent(LifecycleEvent lifecycleEvent) { private static final Log log = LogFactory.getLog(APIPublisherLifecycleListener.class);
if (Lifecycle.AFTER_START_EVENT.equals(lifecycleEvent.getType())) {
StandardContext context = (StandardContext) lifecycleEvent.getLifecycle(); @Override
ServletContext servletContext = context.getServletContext(); public void lifecycleEvent(LifecycleEvent lifecycleEvent) {
if (Lifecycle.AFTER_START_EVENT.equals(lifecycleEvent.getType())) {
StandardContext context = (StandardContext) lifecycleEvent.getLifecycle();
String param = servletContext.getInitParameter(PARAM_MANAGED_API_ENABLED); ServletContext servletContext = context.getServletContext();
boolean isManagedApi = (param != null && !param.isEmpty()) && Boolean.parseBoolean(param); String param = servletContext.getInitParameter(PARAM_MANAGED_API_ENABLED);
boolean isManagedApi = (param != null && !param.isEmpty()) && Boolean.parseBoolean(param);
if (isManagedApi) {
APIConfig apiConfig = this.buildApiConfig(servletContext); if (isManagedApi) {
try { try {
apiConfig.init(); AnnotationUtil annotationUtil = new AnnotationUtil(context);
API api = APIPublisherUtil.getAPI(apiConfig); Set<String> annotatedAPIClasses = annotationUtil.
APIPublisherService apiPublisherService = scanStandardContext(org.wso2.carbon.apimgt.annotations.api.API.class.getName());
APIPublisherDataHolder.getInstance().getApiPublisherService(); List<APIResourceConfiguration> apiDefinitions = annotationUtil.extractAPIInfo(annotatedAPIClasses);
if (apiPublisherService == null) {
throw new IllegalStateException("API Publisher service is not initialized properly"); for (APIResourceConfiguration apiDefinition : apiDefinitions) {
} APIConfig apiConfig = this.buildApiConfig(servletContext, apiDefinition);
apiPublisherService.publishAPI(api); try {
} catch (Throwable e) { int tenantId = APIPublisherDataHolder.getInstance().getTenantManager().getTenantId(apiConfig.getTenantDomain());
/* Throwable is caught as none of the RuntimeExceptions that can potentially occur at this point boolean isTenantActive = APIPublisherDataHolder.getInstance().getTenantManager().isTenantActive(tenantId);
does not seem to be logged anywhere else within the framework */ if (isTenantActive) {
log.error("Error occurred while publishing API '" + apiConfig.getName() + "' with the context '" + apiConfig.init();
apiConfig.getContext() + "' and version '" + apiConfig.getVersion() + "'", e); API api = APIPublisherUtil.getAPI(apiConfig);
} APIPublisherService apiPublisherService =
} APIPublisherDataHolder.getInstance().getApiPublisherService();
} if (apiPublisherService == null) {
} throw new IllegalStateException(
"API Publisher service is not initialized properly");
private APIConfig buildApiConfig(ServletContext servletContext) { }
APIConfig apiConfig = new APIConfig(); apiPublisherService.publishAPI(api);
} else {
String name = servletContext.getInitParameter(PARAM_MANAGED_API_NAME); log.error("No tenant [" + apiConfig.getTenantDomain() + "] found when publishing the webapp");
if (name == null || name.isEmpty()) { }
if (log.isDebugEnabled()) { } catch (Throwable e) {
log.debug("'managed-api-name' attribute is not configured. Therefore, using the default, " + log.error("Error occurred while publishing API '" + apiConfig.getName() +
"which is the name of the web application"); "' with the context '" + apiConfig.getContext() +
} "' and version '" + apiConfig.getVersion() + "'", e);
name = servletContext.getServletContextName(); }
} }
apiConfig.setName(name); } catch (IOException e) {
log.error("Error enconterd while discovering annotated classes", e);
String version = servletContext.getInitParameter(PARAM_MANAGED_API_VERSION); } catch (ClassNotFoundException e) {
if (version == null || version.isEmpty()) { log.error("Error while scanning class for annotations", e);
if (log.isDebugEnabled()) { }
log.debug("'managed-api-version' attribute is not configured. Therefore, using the " + }
"default, which is '1.0.0'"); }
} }
version = API_CONFIG_DEFAULT_VERSION;
} private List<APIResourceConfiguration> mergeAPIDefinitions(List<APIResourceConfiguration> inputList) {
apiConfig.setVersion(version); //TODO : Need to implemented, to merge API Definitions in cases where implementation of an API Lies in two
// classes
String context = servletContext.getInitParameter(PARAM_MANAGED_API_CONTEXT); return null;
if (context == null || context.isEmpty()) { }
if (log.isDebugEnabled()) {
log.debug("'managed-api-context' attribute is not configured. Therefore, using the default, " + /**
"which is the original context assigned to the web application"); * Build the API Configuration to be passed to APIM, from a given list of URL templates
} *
context = servletContext.getContextPath(); * @param servletContext
} * @return
apiConfig.setContext(context); */
private APIConfig buildApiConfig(ServletContext servletContext, APIResourceConfiguration apidef) {
String endpoint = servletContext.getInitParameter(PARAM_MANAGED_API_ENDPOINT); APIConfig apiConfig = new APIConfig();
if (endpoint == null || endpoint.isEmpty()) {
if (log.isDebugEnabled()) { String name = apidef.getName();
log.debug("'managed-api-endpoint' attribute is not configured"); if (name == null || name.isEmpty()) {
} if (log.isDebugEnabled()) {
endpoint = APIPublisherUtil.getApiEndpointUrl(context); log.debug("API Name not set in @API Annotation");
} }
apiConfig.setEndpoint(endpoint); name = servletContext.getServletContextName();
}
String owner = servletContext.getInitParameter(PARAM_MANAGED_API_OWNER); apiConfig.setName(name);
if (owner == null || owner.isEmpty()) {
if (log.isDebugEnabled()) { String version = apidef.getVersion();
log.debug("'managed-api-owner' attribute is not configured"); if (version == null || version.isEmpty()) {
} if (log.isDebugEnabled()) {
} log.debug("'API Version not set in @API Annotation'");
apiConfig.setOwner(owner); }
version = API_CONFIG_DEFAULT_VERSION;
String isSecuredParam = servletContext.getInitParameter(PARAM_MANAGED_API_IS_SECURED); }
boolean isSecured; apiConfig.setVersion(version);
if (isSecuredParam == null || isSecuredParam.isEmpty()) {
if (log.isDebugEnabled()) {
log.debug("'managed-api-isSecured' attribute is not configured. Therefore, using the default, " + String context = apidef.getContext();
"which is 'true'"); if (context == null || context.isEmpty()) {
} if (log.isDebugEnabled()) {
isSecured = false; log.debug("'API Context not set in @API Annotation'");
} else { }
isSecured = Boolean.parseBoolean(isSecuredParam); context = servletContext.getContextPath();
} }
apiConfig.setSecured(isSecured); apiConfig.setContext(context);
String transports = servletContext.getInitParameter(PARAM_MANAGED_API_TRANSPORTS); String[] tags = apidef.getTags();
if (transports == null || transports.isEmpty()) { if (tags == null || tags.length == 0) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("'managed-api-transports' attribute is not configured. Therefore using the default, " + log.debug("'API tag not set in @API Annotation'");
"which is 'https'"); }
} } else {
transports = "https"; apiConfig.setTags(tags);
} }
apiConfig.setTransports(transports);
String contextTemplate = servletContext.getInitParameter(PARAM_MANAGED_API_CONTEXT_TEMPLATE);
return apiConfig; if (contextTemplate == null || contextTemplate.isEmpty()) {
} if (log.isDebugEnabled()) {
log.debug("'managed-api-context-template' attribute is not configured. Therefore, using the default," +
" " +
"which is the original context template assigned to the web application");
}
contextTemplate = servletContext.getContextPath();
}
apiConfig.setContextTemplate(contextTemplate);
String endpoint = servletContext.getInitParameter(PARAM_MANAGED_API_ENDPOINT);
if (endpoint == null || endpoint.isEmpty()) {
if (log.isDebugEnabled()) {
log.debug("'managed-api-endpoint' attribute is not configured");
}
endpoint = APIPublisherUtil.getApiEndpointUrl(context);
}
apiConfig.setEndpoint(endpoint);
String owner = servletContext.getInitParameter(PARAM_MANAGED_API_OWNER);
if (owner == null || owner.isEmpty()) {
if (log.isDebugEnabled()) {
log.debug("'managed-api-owner' attribute is not configured");
}
}
apiConfig.setOwner(owner);
String isSecuredParam = servletContext.getInitParameter(PARAM_MANAGED_API_IS_SECURED);
boolean isSecured;
if (isSecuredParam == null || isSecuredParam.isEmpty()) {
if (log.isDebugEnabled()) {
log.debug("'managed-api-isSecured' attribute is not configured. Therefore, using the default, " +
"which is 'true'");
}
isSecured = false;
} else {
isSecured = Boolean.parseBoolean(isSecuredParam);
}
apiConfig.setSecured(isSecured);
String transports = servletContext.getInitParameter(PARAM_MANAGED_API_TRANSPORTS);
if (transports == null || transports.isEmpty()) {
if (log.isDebugEnabled()) {
log.debug("'managed-api-transports' attribute is not configured. Therefore using the default, " +
"which is 'https'");
}
transports = "https";
}
apiConfig.setTransports(transports);
String sharingValueParam = servletContext.getInitParameter(PARAM_SHARED_WITH_ALL_TENANTS);
boolean isSharedWithAllTenants = (sharingValueParam == null || (!sharingValueParam.isEmpty()) && Boolean.parseBoolean(sharingValueParam) );
apiConfig.setSharedWithAllTenants(isSharedWithAllTenants);
String tenantDomain = servletContext.getInitParameter(PARAM_PROVIDER_TENANT_DOMAIN);
tenantDomain = (tenantDomain!= null && !tenantDomain.isEmpty()) ? tenantDomain : MultitenantConstants.SUPER_TENANT_DOMAIN_NAME;
apiConfig.setTenantDomain(tenantDomain);
Set<URITemplate> uriTemplates = new LinkedHashSet<URITemplate>();
for (APIResource apiResource : apidef.getResources()) {
URITemplate template = new URITemplate();
template.setAuthType(apiResource.getAuthType());
template.setHTTPVerb(apiResource.getHttpVerb());
template.setResourceURI(apiResource.getUri());
template.setUriTemplate(apiResource.getUriTemplate());
uriTemplates.add(template);
}
apiConfig.setUriTemplates(uriTemplates);
return apiConfig;
}
} }

@ -0,0 +1,265 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.apimgt.webapp.publisher.lifecycle.util;
import org.apache.catalina.core.StandardContext;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.scannotation.AnnotationDB;
import org.scannotation.WarUrlFinder;
import org.wso2.carbon.apimgt.webapp.publisher.config.APIResource;
import org.wso2.carbon.apimgt.webapp.publisher.config.APIResourceConfiguration;
import javax.servlet.ServletContext;
import javax.ws.rs.*;
import java.io.IOException;
import java.lang.annotation.Annotation;
import java.lang.reflect.InvocationHandler;
import java.lang.reflect.Method;
import java.lang.reflect.Proxy;
import java.net.URL;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.*;
public class AnnotationUtil {
private static final Log log = LogFactory.getLog(AnnotationUtil.class);
private static final String PACKAGE_ORG_APACHE = "org.apache";
private static final String PACKAGE_ORG_CODEHAUS = "org.codehaus";
private static final String PACKAGE_ORG_SPRINGFRAMEWORK = "org.springframework";
private static final String AUTH_TYPE = "Any";
private static final String PROTOCOL_HTTP = "http";
private static final String SERVER_HOST = "carbon.local.ip";
private static final String HTTP_PORT = "httpPort";
public static final String DIR_WEB_INF_LIB = "/WEB-INF/lib";
public static final String STRING_ARR = "string_arr";
public static final String STRING = "string";
private StandardContext context;
private Method[] pathClazzMethods;
private Class<Path> pathClazz;
private ClassLoader classLoader;
private ServletContext servletContext;
public AnnotationUtil(final StandardContext context) {
this.context = context;
servletContext = context.getServletContext();
classLoader = servletContext.getClassLoader();
}
/**
* Scan the context for classes with annotations
* @return
* @throws IOException
*/
public Set<String> scanStandardContext(String className) throws IOException {
AnnotationDB db = new AnnotationDB();
db.addIgnoredPackages(PACKAGE_ORG_APACHE);
db.addIgnoredPackages(PACKAGE_ORG_CODEHAUS);
db.addIgnoredPackages(PACKAGE_ORG_SPRINGFRAMEWORK);
URL[] libPath = WarUrlFinder.findWebInfLibClasspaths(servletContext);
URL classPath = WarUrlFinder.findWebInfClassesPath(servletContext);
URL[] urls = (URL[]) ArrayUtils.add(libPath, libPath.length, classPath);
db.scanArchives(urls);
//Returns a list of classes with given Annotation
return db.getAnnotationIndex().get(className);
}
/**
* Method identifies the URL templates and context by reading the annotations of a class
* @param entityClasses
* @return
*/
public List<APIResourceConfiguration> extractAPIInfo(Set<String> entityClasses)
throws ClassNotFoundException {
List<APIResourceConfiguration> apiResourceConfigs = new ArrayList<APIResourceConfiguration>();
if (entityClasses != null && !entityClasses.isEmpty()) {
for (final String className : entityClasses) {
APIResourceConfiguration resource =
AccessController.doPrivileged(new PrivilegedAction<APIResourceConfiguration>() {
public APIResourceConfiguration run() {
Class<?> clazz = null;
APIResourceConfiguration apiResourceConfig = null;
try {
clazz = classLoader.loadClass(className);
Class<Path> apiClazz = (Class<Path>)
classLoader.loadClass(org.wso2.carbon.apimgt.annotations.api.API.class.getName());
Annotation apiAnno = clazz.getAnnotation(apiClazz);
List<APIResource> resourceList = null;
apiResourceConfig = new APIResourceConfiguration();
if (apiAnno != null) {
Method[] apiClazzMethods = apiClazz.getMethods();
if (log.isDebugEnabled()) {
log.debug("Application Context root = " + servletContext.getContextPath());
}
try {
for(int k=0;k<apiClazzMethods.length;k++){
switch (apiClazzMethods[k].getName()){
case "name" :
apiResourceConfig.setName(invokeMethod(apiClazzMethods[k], apiAnno, STRING));
break;
case "version" :
apiResourceConfig.setVersion(invokeMethod(apiClazzMethods[k], apiAnno, STRING));
break;
case "context" :
apiResourceConfig.setContext(invokeMethod(apiClazzMethods[k], apiAnno, STRING));
break;
case "tags" :
apiResourceConfig.setTags(invokeMethod(apiClazzMethods[k], apiAnno));
break;
}
}
String rootContext = "";
pathClazz = (Class<Path>) classLoader.loadClass(Path.class.getName());
pathClazzMethods = pathClazz.getMethods();
Annotation rootContectAnno = clazz.getAnnotation(pathClazz);
if (rootContectAnno != null) {
rootContext = invokeMethod(pathClazzMethods[0], rootContectAnno, STRING);
if (log.isDebugEnabled()) {
log.debug("API Root Context = " + rootContext);
}
}
Method[] annotatedMethods = clazz.getDeclaredMethods();
resourceList = getApiResources(rootContext, annotatedMethods);
apiResourceConfig.setResources(resourceList);
} catch (Throwable throwable) {
log.error("Error encountered while scanning for annotations", throwable);
}
}
} catch (ClassNotFoundException e) {
log.error("Error when passing the api annotation for device type apis.");
}
return apiResourceConfig;
}
});
apiResourceConfigs.add(resource);
}
}
return apiResourceConfigs;
}
private List<APIResource> getApiResources(String rootContext, Method[] annotatedMethods) throws Throwable {
List<APIResource> resourceList;
resourceList = new ArrayList<APIResource>();
for (Method method : annotatedMethods) {
Annotation methodContextAnno = method.getAnnotation(pathClazz);
if (methodContextAnno != null) {
String subCtx = invokeMethod(pathClazzMethods[0], methodContextAnno, STRING);
APIResource resource = new APIResource();
resource.setUriTemplate(makeContextURLReady(subCtx));
String serverIP = System.getProperty(SERVER_HOST);
String httpServerPort = System.getProperty(HTTP_PORT);
resource.setUri(PROTOCOL_HTTP + "://" + serverIP + ":" + httpServerPort + makeContextURLReady(rootContext) + makeContextURLReady(subCtx));
resource.setAuthType(AUTH_TYPE);
Annotation[] annotations = method.getDeclaredAnnotations();
for(int i=0; i<annotations.length; i++){
if(annotations[i].annotationType().getName().equals(GET.class.getName())){
resource.setHttpVerb(HttpMethod.GET);
}
if(annotations[i].annotationType().getName().equals(POST.class.getName())){
resource.setHttpVerb(HttpMethod.POST);
}
if(annotations[i].annotationType().getName().equals(OPTIONS.class.getName())){
resource.setHttpVerb(HttpMethod.OPTIONS);
}
if(annotations[i].annotationType().getName().equals(DELETE.class.getName())){
resource.setHttpVerb(HttpMethod.DELETE);
}
if(annotations[i].annotationType().getName().equals(PUT.class.getName())){
resource.setHttpVerb(HttpMethod.PUT);
}
if(annotations[i].annotationType().getName().equals(Consumes.class.getName())){
Class<Consumes> consumesClass = (Class<Consumes>) classLoader.loadClass(Consumes.class.getName());
Method[] consumesClassMethods = consumesClass.getMethods();
Annotation consumesAnno = method.getAnnotation(consumesClass);
resource.setConsumes(invokeMethod(consumesClassMethods[0], consumesAnno, STRING_ARR));
}
if(annotations[i].annotationType().getName().equals(Produces.class.getName())){
Class<Produces> producesClass = (Class<Produces>) classLoader.loadClass(Produces.class.getName());
Method[] producesClassMethods = producesClass.getMethods();
Annotation producesAnno = method.getAnnotation(producesClass);
resource.setProduces(invokeMethod(producesClassMethods[0], producesAnno, STRING_ARR));
}
}
resourceList.add(resource);
}
}
return resourceList;
}
private String makeContextURLReady(String context){
if(context != null && !context.equalsIgnoreCase("")){
if(context.startsWith("/")){
return context;
}else{
return "/"+context;
}
}
return "";
}
/**
* When an annotation and method is passed, this method invokes that executes said method against the annotation
* @param method
* @param annotation
* @param returnType
* @return
* @throws Throwable
*/
private String invokeMethod(Method method, Annotation annotation, String returnType) throws Throwable {
InvocationHandler methodHandler = Proxy.getInvocationHandler(annotation);
switch (returnType){
case STRING:
return (String) methodHandler.invoke(annotation, method, null);
case STRING_ARR:
return ((String[])methodHandler.invoke(annotation, method, null))[0];
default:
return null;
}
}
/**
* When an annotation and method is passed, this method invokes that executes said method against the annotation
*/
private String[] invokeMethod(Method method, Annotation annotation) throws Throwable {
InvocationHandler methodHandler = Proxy.getInvocationHandler(annotation);
return ((String[])methodHandler.invoke(annotation, method, null));
}
}

@ -1,144 +0,0 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
~
~ WSO2 Inc. licenses this file to you under the Apache License,
~ Version 2.0 (the "License"); you may not use this file except
~ in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>device-mgt</artifactId>
<version>1.1.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>org.wso2.carbon.device.mgt.analytics</artifactId>
<version>1.1.0-SNAPSHOT</version>
<packaging>bundle</packaging>
<name>WSO2 Carbon - Device Analytics</name>
<description>WSO2 Carbon - Device Analytics</description>
<url>http://wso2.org</url>
<dependencies>
<dependency>
<groupId>org.eclipse.osgi</groupId>
<artifactId>org.eclipse.osgi</artifactId>
</dependency>
<dependency>
<groupId>org.eclipse.osgi</groupId>
<artifactId>org.eclipse.osgi.services</artifactId>
</dependency>
<dependency>
<groupId>org.testng</groupId>
<artifactId>testng</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.tomcat</groupId>
<artifactId>tomcat</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.tomcat</groupId>
<artifactId>tomcat-servlet-api</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.core</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.logging</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.utils</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.device.mgt.core</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.analytics-common</groupId>
<artifactId>org.wso2.carbon.databridge.agent</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.analytics-common</groupId>
<artifactId>org.wso2.carbon.databridge.commons</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.analytics</groupId>
<artifactId>org.wso2.carbon.analytics.api</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.registry</groupId>
<artifactId>org.wso2.carbon.registry.indexing</artifactId>
</dependency>
<dependency>
<groupId>org.json.wso2</groupId>
<artifactId>json</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-scr-plugin</artifactId>
</plugin>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-bundle-plugin</artifactId>
<version>1.4.0</version>
<extensions>true</extensions>
<configuration>
<instructions>
<Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
<Bundle-Name>${project.artifactId}</Bundle-Name>
<Bundle-Version>${carbon.device.mgt.version}</Bundle-Version>
<Bundle-Description>Data Publisher</Bundle-Description>
<Private-Package>org.wso2.carbon.device.mgt.analytics.internal</Private-Package>
<Export-Package>
!org.wso2.carbon.device.mgt.analytics.internal,
org.wso2.carbon.device.mgt.analytics.*;version="${carbon.device.mgt.version}"
</Export-Package>
<Import-Package>
org.osgi.framework,
org.osgi.service.component,
org.apache.commons.logging.*,
org.wso2.carbon.context;version="${carbon.kernel.version.range}",
org.wso2.carbon.utils;version="${carbon.kernel.version.range}",
org.wso2.carbon.databridge.*;version="${carbon.analytics.common.version.range}",
org.wso2.carbon.analytics.*;version="${carbon.analytics.version.range}",
org.wso2.carbon.registry.core.*;resolution:=optional,
org.wso2.carbon.registry.common.*;version="${carbon.registry.imp.pkg.version.range}",
org.wso2.carbon.registry.indexing.*; version="${carbon.registry.imp.pkg.version.range}",
org.json;version="${commons-json.version}",
javax.xml.bind,
javax.xml.bind.annotation,
javax.xml.parsers,
org.w3c.dom,
org.wso2.carbon.base
</Import-Package>
</instructions>
</configuration>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,69 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.device.mgt.common;
import java.io.Serializable;
/**
* This class holds the information of the device type and its provider tenant.
*/
public class DeviceTypeIdentifier implements Serializable {
private String deviceType;
private int tenantId;
private static final int DEFAULT_SHARE_WITH_ALL_TENANTS_ID = -1;
public DeviceTypeIdentifier(String deviceType, int tenantId) {
this.deviceType = deviceType;
this.tenantId = tenantId;
}
public DeviceTypeIdentifier(String deviceType) {
this.deviceType = deviceType;
this.tenantId = DEFAULT_SHARE_WITH_ALL_TENANTS_ID;
}
public void setTenantId(int tenantId) {
this.tenantId = tenantId;
}
public String getDeviceType() {
return this.deviceType;
}
public int getTenantId() {
return this.tenantId;
}
@Override
public int hashCode() {
int result = this.deviceType.hashCode();
result = 31 * result + ("@" + this.tenantId).hashCode();
return result;
}
@Override
public boolean equals(Object obj) {
return (obj instanceof DeviceTypeIdentifier) && deviceType.equals(
((DeviceTypeIdentifier) obj).deviceType) && tenantId == ((DeviceTypeIdentifier) obj).tenantId;
}
public boolean isSharedWithAllTenant() {
return tenantId == DEFAULT_SHARE_WITH_ALL_TENANTS_ID;
}
}

@ -39,6 +39,19 @@ public interface DeviceManagementService extends ApplicationManager {
*/ */
String getType(); String getType();
/**
* This returns the tenant domain of the provider.
* @return
*/
String getProviderTenantDomain();
/**
* returns true if the device type is shared between all tenants and false if its not.
*
* @return
*/
boolean isSharedWithAllTenants();
void init() throws DeviceManagementException; void init() throws DeviceManagementException;
DeviceManager getDeviceManager(); DeviceManager getDeviceManager();

@ -83,7 +83,8 @@
org.apache.catalina.core, org.apache.catalina.core,
org.apache.commons.collections, org.apache.commons.collections,
org.wso2.carbon.email.sender.*, org.wso2.carbon.email.sender.*,
org.wso2.carbon org.wso2.carbon,
org.wso2.carbon.base
</Import-Package> </Import-Package>
<Export-Package> <Export-Package>
!org.wso2.carbon.device.mgt.core.internal, !org.wso2.carbon.device.mgt.core.internal,

@ -20,6 +20,7 @@ package org.wso2.carbon.device.mgt.core;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.DeviceTypeIdentifier;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService; import org.wso2.carbon.device.mgt.common.spi.DeviceManagementService;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder; import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent; import org.wso2.carbon.device.mgt.core.internal.DeviceManagementServiceComponent;
@ -32,23 +33,29 @@ import java.util.Map;
public class DeviceManagementPluginRepository implements DeviceManagerStartupListener { public class DeviceManagementPluginRepository implements DeviceManagerStartupListener {
private Map<String, DeviceManagementService> providers; private Map<DeviceTypeIdentifier, DeviceManagementService> providers;
private boolean isInited; private boolean isInited;
private static final Log log = LogFactory.getLog(DeviceManagementPluginRepository.class); private static final Log log = LogFactory.getLog(DeviceManagementPluginRepository.class);
public DeviceManagementPluginRepository() { public DeviceManagementPluginRepository() {
providers = Collections.synchronizedMap(new HashMap<String, DeviceManagementService>()); providers = Collections.synchronizedMap(new HashMap<DeviceTypeIdentifier, DeviceManagementService>());
DeviceManagementServiceComponent.registerStartupListener(this); DeviceManagementServiceComponent.registerStartupListener(this);
} }
public void addDeviceManagementProvider(DeviceManagementService provider) throws DeviceManagementException { public void addDeviceManagementProvider(DeviceManagementService provider) throws DeviceManagementException {
String deviceType = provider.getType(); String deviceType = provider.getType();
String tenantDomain = provider.getProviderTenantDomain();
boolean isSharedWithAllTenants = provider.isSharedWithAllTenants();
int tenantId = DeviceManagerUtil.getTenantId(tenantDomain);
if (tenantId == -1) {
throw new DeviceManagementException("No tenant available for tenant domain " + tenantDomain);
}
synchronized (providers) { synchronized (providers) {
try { try {
if (isInited) { if (isInited) {
/* Initializing Device Management Service Provider */ /* Initializing Device Management Service Provider */
provider.init(); provider.init();
DeviceManagerUtil.registerDeviceType(deviceType); DeviceManagerUtil.registerDeviceType(deviceType, tenantId, isSharedWithAllTenants);
DeviceManagementDataHolder.getInstance().setRequireDeviceAuthorization(deviceType, DeviceManagementDataHolder.getInstance().setRequireDeviceAuthorization(deviceType,
provider.getDeviceManager().requireDeviceAuthorization()); provider.getDeviceManager().requireDeviceAuthorization());
@ -57,20 +64,47 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
throw new DeviceManagementException("Error occurred while adding device management provider '" + throw new DeviceManagementException("Error occurred while adding device management provider '" +
deviceType + "'", e); deviceType + "'", e);
} }
providers.put(deviceType, provider); if (isSharedWithAllTenants) {
DeviceTypeIdentifier deviceTypeIdentifier = new DeviceTypeIdentifier(deviceType);
providers.put(deviceTypeIdentifier, provider);
} else {
DeviceTypeIdentifier deviceTypeIdentifier = new DeviceTypeIdentifier(deviceType, tenantId);
providers.put(deviceTypeIdentifier, provider);
}
} }
} }
public void removeDeviceManagementProvider(DeviceManagementService provider) throws DeviceManagementException { public void removeDeviceManagementProvider(DeviceManagementService provider) throws DeviceManagementException {
providers.remove(provider.getType()); String deviceTypeName=provider.getType();
if(provider.isSharedWithAllTenants()){
DeviceTypeIdentifier deviceTypeIdentifier =new DeviceTypeIdentifier(deviceTypeName);
providers.remove(deviceTypeIdentifier);
}else{
int providerTenantId=DeviceManagerUtil.getTenantId(provider.getProviderTenantDomain());
DeviceTypeIdentifier deviceTypeIdentifier =new DeviceTypeIdentifier(deviceTypeName, providerTenantId);
providers.remove(deviceTypeIdentifier);
}
} }
public DeviceManagementService getDeviceManagementService(String type) { public DeviceManagementService getDeviceManagementService(String type, int tenantId) {
return providers.get(type); //Priority need to be given to the tenant before public.
DeviceTypeIdentifier deviceTypeIdentifier = new DeviceTypeIdentifier(type, tenantId);
DeviceManagementService provider = providers.get(deviceTypeIdentifier);
if (provider == null) {
deviceTypeIdentifier = new DeviceTypeIdentifier(type);
provider = providers.get(deviceTypeIdentifier);
}
return provider;
} }
public Map<String, DeviceManagementService> getAllDeviceManagementServices() { public Map<DeviceTypeIdentifier, DeviceManagementService> getAllDeviceManagementServices(int tenantId) {
return providers; Map<DeviceTypeIdentifier, DeviceManagementService> tenantProviders = new HashMap<>();
for (DeviceTypeIdentifier identifier : providers.keySet()) {
if (identifier.getTenantId() == tenantId || identifier.isSharedWithAllTenant()) {
tenantProviders.put(identifier, providers.get(identifier));
}
}
return tenantProviders;
} }
@Override @Override
@ -79,7 +113,8 @@ public class DeviceManagementPluginRepository implements DeviceManagerStartupLis
for (DeviceManagementService provider : providers.values()) { for (DeviceManagementService provider : providers.values()) {
try { try {
provider.init(); provider.init();
DeviceManagerUtil.registerDeviceType(provider.getType()); int tenantId=DeviceManagerUtil.getTenantId(provider.getProviderTenantDomain());
DeviceManagerUtil.registerDeviceType(provider.getType(), tenantId, provider.isSharedWithAllTenants());
//TODO: //TODO:
//This is a temporory fix. //This is a temporory fix.
//windows and IOS cannot resolve user info by extracting certs //windows and IOS cannot resolve user info by extracting certs

@ -27,18 +27,64 @@ import java.util.List;
*/ */
public interface DeviceTypeDAO { public interface DeviceTypeDAO {
void addDeviceType(DeviceType deviceType) throws DeviceManagementDAOException; /**
* @param deviceType device that needs to be added
* @param providerTenantId provider tenant id whom the device type is associated with.
* @param isSharedWithAllTenants is this a shared device type or not.
* @throws DeviceManagementDAOException
*/
void addDeviceType(DeviceType deviceType, int providerTenantId, boolean isSharedWithAllTenants)
throws DeviceManagementDAOException;
void updateDeviceType(DeviceType deviceType) throws DeviceManagementDAOException; /**
* @param deviceType deviceType that needs to be updated.
* @param providerTenantId provider tenant id whom the device type is associated with.
* @throws DeviceManagementDAOException
*/
void updateDeviceType(DeviceType deviceType, int providerTenantId) throws DeviceManagementDAOException;
List<DeviceType> getDeviceTypes() throws DeviceManagementDAOException; /**
* @param tenantId get device type detail of a specific tenant.
* @return list of all device types that are associated with the tenant this includes the shared device types.
* @throws DeviceManagementDAOException
*/
List<DeviceType> getDeviceTypes(int tenantId) throws DeviceManagementDAOException;
List<DeviceType> getDeviceTypes(int tenantId) throws DeviceManagementDAOException; /**
* @param tenandId of the device type provider.
* @return return only the device types that are associated with the provider tenant.
* @throws DeviceManagementDAOException
*/
List<DeviceType> getDeviceTypesByProvider(int tenandId) throws DeviceManagementDAOException;
/**
* @return sharedWithAllDeviceTypes This returns public shared device types.
* @throws DeviceManagementDAOException
*/
List<DeviceType> getSharedDeviceTypes() throws DeviceManagementDAOException;
/**
* @param id retrieve the device type with its id.
* @return the device type associated with the id.
* @throws DeviceManagementDAOException
*/
DeviceType getDeviceType(int id) throws DeviceManagementDAOException; DeviceType getDeviceType(int id) throws DeviceManagementDAOException;
DeviceType getDeviceType(String name) throws DeviceManagementDAOException; /**
* @param name retreive the device type with it name.
* @param tenantId retreive the device type with its tenant id.
* @return the device type associated with its name and tenant id.
* @throws DeviceManagementDAOException
*/
DeviceType getDeviceType(String name, int tenantId) throws DeviceManagementDAOException;
void removeDeviceType(String type) throws DeviceManagementDAOException; /**
* remove the device type from tenant.
*
* @param name remove the device type with it name.
* @param tenantId remove the device type with its tenant id.
* @throws DeviceManagementDAOException
*/
void removeDeviceType(String name, int tenantId) throws DeviceManagementDAOException;
} }

@ -32,143 +32,179 @@ import java.util.List;
public class DeviceTypeDAOImpl implements DeviceTypeDAO { public class DeviceTypeDAOImpl implements DeviceTypeDAO {
@Override @Override
public void addDeviceType(DeviceType deviceType) throws DeviceManagementDAOException { public void addDeviceType(DeviceType deviceType, int providerTenantId, boolean isSharedWithAllTenants)
Connection conn; throws DeviceManagementDAOException {
PreparedStatement stmt = null; Connection conn;
try { PreparedStatement stmt = null;
conn = this.getConnection(); try {
stmt = conn.prepareStatement("INSERT INTO DM_DEVICE_TYPE (NAME) VALUES (?)"); conn = this.getConnection();
stmt.setString(1, deviceType.getName()); stmt = conn.prepareStatement(
stmt.execute(); "INSERT INTO DM_DEVICE_TYPE (NAME,PROVIDER_TENANT_ID,SHARED_WITH_ALL_TENANTS) VALUES (?,?,?)");
} catch (SQLException e) { stmt.setString(1, deviceType.getName());
throw new DeviceManagementDAOException("Error occurred while registering the device type " + stmt.setInt(2, providerTenantId);
"'" + deviceType.getName() + "'", e); stmt.setBoolean(3, isSharedWithAllTenants);
} finally { stmt.execute();
DeviceManagementDAOUtil.cleanupResources(stmt, null); } catch (SQLException e) {
} throw new DeviceManagementDAOException(
} "Error occurred while registering the device type '" + deviceType.getName() + "'", e);
} finally {
@Override DeviceManagementDAOUtil.cleanupResources(stmt, null);
public void updateDeviceType(DeviceType deviceType) throws DeviceManagementDAOException { }
}
}
@Override
@Override public void updateDeviceType(DeviceType deviceType, int tenantId)
public List<DeviceType> getDeviceTypes() throws DeviceManagementDAOException { throws DeviceManagementDAOException {
Connection conn; }
PreparedStatement stmt = null;
ResultSet rs = null; @Override
List<DeviceType> deviceTypes = new ArrayList<>(); public List<DeviceType> getDeviceTypes(int tenantId) throws DeviceManagementDAOException {
try { Connection conn;
conn = this.getConnection(); PreparedStatement stmt = null;
String sql = "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE"; ResultSet rs = null;
stmt = conn.prepareStatement(sql); List<DeviceType> deviceTypes = new ArrayList<>();
rs = stmt.executeQuery(); try {
conn = this.getConnection();
while (rs.next()) { String sql =
DeviceType deviceType = new DeviceType(); "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE where PROVIDER_TENANT_ID =" +
deviceType.setId(rs.getInt("DEVICE_TYPE_ID")); "? OR SHARED_WITH_ALL_TENANTS = TRUE";
deviceType.setName(rs.getString("DEVICE_TYPE")); stmt = conn.prepareStatement(sql);
deviceTypes.add(deviceType); stmt.setInt(1, tenantId);
} rs = stmt.executeQuery();
return deviceTypes;
} catch (SQLException e) { while (rs.next()) {
throw new DeviceManagementDAOException("Error occurred while fetching the registered device types", e); DeviceType deviceType = new DeviceType();
} finally { deviceType.setId(rs.getInt("DEVICE_TYPE_ID"));
DeviceManagementDAOUtil.cleanupResources(stmt, rs); deviceType.setName(rs.getString("DEVICE_TYPE"));
} deviceTypes.add(deviceType);
} }
return deviceTypes;
@Override } catch (SQLException e) {
public List<DeviceType> getDeviceTypes(int tenantId) throws DeviceManagementDAOException { throw new DeviceManagementDAOException("Error occurred while fetching the registered device types", e);
Connection conn; } finally {
PreparedStatement stmt = null; DeviceManagementDAOUtil.cleanupResources(stmt, rs);
ResultSet rs = null; }
List<DeviceType> deviceTypes = new ArrayList<>(); }
try {
conn = this.getConnection(); @Override
String sql = public List<DeviceType> getDeviceTypesByProvider(int tenantId) throws DeviceManagementDAOException {
"SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE where PROVIDER_TENANT_ID =" + Connection conn;
"? OR SHARED_WITH_ALL_TENANTS = TRUE"; PreparedStatement stmt = null;
stmt = conn.prepareStatement(sql); ResultSet rs = null;
stmt.setInt(1, tenantId); List<DeviceType> deviceTypes = new ArrayList<>();
rs = stmt.executeQuery(); try {
conn = this.getConnection();
while (rs.next()) { String sql =
DeviceType deviceType = new DeviceType(); "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE where PROVIDER_TENANT_ID =?";
deviceType.setId(rs.getInt("DEVICE_TYPE_ID")); stmt = conn.prepareStatement(sql);
deviceType.setName(rs.getString("DEVICE_TYPE")); stmt.setInt(1, tenantId);
deviceTypes.add(deviceType); rs = stmt.executeQuery();
}
return deviceTypes; while (rs.next()) {
} catch (SQLException e) { DeviceType deviceType = new DeviceType();
throw new DeviceManagementDAOException("Error occurred while fetching the registered device types", e); deviceType.setId(rs.getInt("DEVICE_TYPE_ID"));
} finally { deviceType.setName(rs.getString("DEVICE_TYPE"));
DeviceManagementDAOUtil.cleanupResources(stmt, rs); deviceTypes.add(deviceType);
} }
} return deviceTypes;
} catch (SQLException e) {
@Override throw new DeviceManagementDAOException("Error occurred while fetching the registered device types", e);
public DeviceType getDeviceType(int id) throws DeviceManagementDAOException { } finally {
Connection conn; DeviceManagementDAOUtil.cleanupResources(stmt, rs);
PreparedStatement stmt = null; }
ResultSet rs = null; }
try {
conn = this.getConnection(); @Override
String sql = "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE WHERE ID = ?"; public List<DeviceType> getSharedDeviceTypes() throws DeviceManagementDAOException {
stmt = conn.prepareStatement(sql); Connection conn;
stmt.setInt(1, id); PreparedStatement stmt = null;
ResultSet rs = null;
rs = stmt.executeQuery(); List<DeviceType> deviceTypes = new ArrayList<>();
DeviceType deviceType = null; try {
while (rs.next()) { conn = this.getConnection();
deviceType = new DeviceType(); String sql =
deviceType.setId(rs.getInt("DEVICE_TYPE_ID")); "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE where " +
deviceType.setName(rs.getString("DEVICE_TYPE")); "SHARED_WITH_ALL_TENANTS = TRUE";
} stmt = conn.prepareStatement(sql);
return deviceType; rs = stmt.executeQuery();
} catch (SQLException e) {
throw new DeviceManagementDAOException("Error occurred while fetching the registered device type", e); while (rs.next()) {
} finally { DeviceType deviceType = new DeviceType();
DeviceManagementDAOUtil.cleanupResources(stmt, rs); deviceType.setId(rs.getInt("DEVICE_TYPE_ID"));
} deviceType.setName(rs.getString("DEVICE_TYPE"));
} deviceTypes.add(deviceType);
}
@Override return deviceTypes;
public DeviceType getDeviceType(String type) throws DeviceManagementDAOException { } catch (SQLException e) {
Connection conn; throw new DeviceManagementDAOException("Error occurred while fetching the registered device types", e);
PreparedStatement stmt = null; } finally {
ResultSet rs = null; DeviceManagementDAOUtil.cleanupResources(stmt, rs);
DeviceType deviceType = null; }
try { }
conn = this.getConnection();
String sql = "SELECT ID From DM_DEVICE_TYPE WHERE NAME = ?"; @Override
stmt = conn.prepareStatement(sql); public DeviceType getDeviceType(int id) throws DeviceManagementDAOException {
stmt.setString(1, type); Connection conn;
rs = stmt.executeQuery(); PreparedStatement stmt = null;
ResultSet rs = null;
if (rs.next()) { try {
deviceType = new DeviceType(); conn = this.getConnection();
deviceType.setId(rs.getInt("ID")); String sql = "SELECT ID AS DEVICE_TYPE_ID, NAME AS DEVICE_TYPE FROM DM_DEVICE_TYPE WHERE ID = ?";
deviceType.setName(type); stmt = conn.prepareStatement(sql);
} stmt.setInt(1, id);
return deviceType; rs = stmt.executeQuery();
} catch (SQLException e) { DeviceType deviceType = null;
throw new DeviceManagementDAOException("Error occurred while fetch device type id for device type " + while (rs.next()) {
"'" + type + "'", e); deviceType = new DeviceType();
} finally { deviceType.setId(rs.getInt("DEVICE_TYPE_ID"));
DeviceManagementDAOUtil.cleanupResources(stmt, rs); deviceType.setName(rs.getString("DEVICE_TYPE"));
} }
} return deviceType;
} catch (SQLException e) {
@Override throw new DeviceManagementDAOException(
public void removeDeviceType(String type) throws DeviceManagementDAOException { "Error occurred while fetching the registered device type", e);
} finally {
} DeviceManagementDAOUtil.cleanupResources(stmt, rs);
}
private Connection getConnection() throws SQLException { }
return DeviceManagementDAOFactory.getConnection();
} @Override
public DeviceType getDeviceType(String type, int tenantId) throws
DeviceManagementDAOException {
Connection conn;
PreparedStatement stmt = null;
ResultSet rs = null;
DeviceType deviceType = null;
try {
conn = this.getConnection();
String sql = "SELECT ID AS DEVICE_TYPE_ID FROM DM_DEVICE_TYPE WHERE (PROVIDER_TENANT_ID =? OR " +
"SHARED_WITH_ALL_TENANTS = TRUE) AND NAME =?";
stmt = conn.prepareStatement(sql);
stmt.setInt(1, tenantId);
stmt.setString(2, type);
rs = stmt.executeQuery();
if (rs.next()) {
deviceType = new DeviceType();
deviceType.setId(rs.getInt("DEVICE_TYPE_ID"));
deviceType.setName(type);
}
return deviceType;
} catch (SQLException e) {
throw new DeviceManagementDAOException(
"Error occurred while fetch device type id for device type '" + type + "'", e);
} finally {
DeviceManagementDAOUtil.cleanupResources(stmt, rs);
}
}
@Override
public void removeDeviceType(String type, int tenantId) throws DeviceManagementDAOException {
}
private Connection getConnection() throws SQLException {
return DeviceManagementDAOFactory.getConnection();
}
} }

@ -67,7 +67,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
@Override @Override
public boolean saveConfiguration(TenantConfiguration configuration) throws DeviceManagementException { public boolean saveConfiguration(TenantConfiguration configuration) throws DeviceManagementException {
DeviceManager dms = DeviceManager dms =
this.getPluginRepository().getDeviceManagementService(configuration.getType()).getDeviceManager(); this.getPluginRepository().getDeviceManagementService(configuration.getType(), this.getTenantId()).getDeviceManager();
return dms.saveConfiguration(configuration); return dms.saveConfiguration(configuration);
} }
@ -79,7 +79,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
@Override @Override
public TenantConfiguration getConfiguration(String deviceType) throws DeviceManagementException { public TenantConfiguration getConfiguration(String deviceType) throws DeviceManagementException {
DeviceManager dms = DeviceManager dms =
this.getPluginRepository().getDeviceManagementService(deviceType).getDeviceManager(); this.getPluginRepository().getDeviceManagementService(deviceType, this.getTenantId()).getDeviceManager();
if (dms == null) { if (dms == null) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Device type '" + deviceType + "' does not have an associated device management " + log.debug("Device type '" + deviceType + "' does not have an associated device management " +
@ -185,7 +185,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
int enrolmentId = 0; int enrolmentId = 0;
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceType type = deviceTypeDAO.getDeviceType(device.getType()); DeviceType type = deviceTypeDAO.getDeviceType(device.getType(), tenantId);
int deviceId = deviceDAO.addDevice(type.getId(), device, tenantId); int deviceId = deviceDAO.addDevice(type.getId(), device, tenantId);
enrolmentId = enrollmentDAO.addEnrollment(deviceId, device.getEnrolmentInfo(), tenantId); enrolmentId = enrollmentDAO.addEnrollment(deviceId, device.getEnrolmentInfo(), tenantId);
DeviceManagementDAOFactory.commitTransaction(); DeviceManagementDAOFactory.commitTransaction();
@ -226,7 +226,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
try { try {
int tenantId = this.getTenantId(); int tenantId = this.getTenantId();
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceType type = deviceTypeDAO.getDeviceType(device.getType()); DeviceType type = deviceTypeDAO.getDeviceType(device.getType(), tenantId);
deviceDAO.updateDevice(type.getId(), device, tenantId); deviceDAO.updateDevice(type.getId(), device, tenantId);
enrollmentDAO.updateEnrollment(device.getEnrolmentInfo()); enrollmentDAO.updateEnrollment(device.getEnrolmentInfo());
DeviceManagementDAOFactory.commitTransaction(); DeviceManagementDAOFactory.commitTransaction();
@ -287,7 +287,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
} }
return false; return false;
} }
DeviceType deviceType = deviceTypeDAO.getDeviceType(device.getType()); DeviceType deviceType = deviceTypeDAO.getDeviceType(device.getType(), tenantId);
device.getEnrolmentInfo().setDateOfLastUpdate(new Date().getTime()); device.getEnrolmentInfo().setDateOfLastUpdate(new Date().getTime());
device.getEnrolmentInfo().setStatus(EnrolmentInfo.Status.REMOVED); device.getEnrolmentInfo().setStatus(EnrolmentInfo.Status.REMOVED);
@ -621,22 +621,40 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
@Override @Override
public List<DeviceType> getAvailableDeviceTypes() throws DeviceManagementException { public List<DeviceType> getAvailableDeviceTypes() throws DeviceManagementException {
List<DeviceType> deviceTypesInDatabase; List<DeviceType> deviceTypesProvidedByTenant;
List<DeviceType> publicSharedDeviceTypesInDB;
List<DeviceType> deviceTypesResponse = new ArrayList<>(); List<DeviceType> deviceTypesResponse = new ArrayList<>();
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
deviceTypesInDatabase = deviceDAO.getDeviceTypes(); int tenantId = this.getTenantId();
Map<String, DeviceManagementService> registeredTypes = pluginRepository.getAllDeviceManagementServices(); deviceTypesProvidedByTenant = deviceTypeDAO.getDeviceTypesByProvider(tenantId);
DeviceType deviceType; publicSharedDeviceTypesInDB = deviceTypeDAO.getSharedDeviceTypes();
if (registeredTypes != null && deviceTypesInDatabase != null) { Map<DeviceTypeIdentifier, DeviceManagementService> registeredTypes =
for (DeviceType aDeviceTypesInDatabase : deviceTypesInDatabase) { pluginRepository.getAllDeviceManagementServices(tenantId);
if (registeredTypes.get(aDeviceTypesInDatabase.getName()) != null) { Set<String> deviceTypeSetForTenant = new HashSet<>();
deviceType = new DeviceType();
deviceType.setId(aDeviceTypesInDatabase.getId()); if (registeredTypes != null) {
deviceType.setName(aDeviceTypesInDatabase.getName()); if (deviceTypesProvidedByTenant != null) {
deviceTypesResponse.add(deviceType); for (DeviceType deviceType : deviceTypesProvidedByTenant) {
DeviceTypeIdentifier providerKey = new DeviceTypeIdentifier(deviceType.getName(), tenantId);
if (registeredTypes.get(providerKey) != null) {
deviceTypesResponse.add(deviceType);
deviceTypeSetForTenant.add(deviceType.getName());
}
}
}
// Get the device from the public space, however if there is another device with same name then give
// priority to that
if (publicSharedDeviceTypesInDB != null) {
for (DeviceType deviceType : publicSharedDeviceTypesInDB) {
DeviceTypeIdentifier providerKey = new DeviceTypeIdentifier(deviceType.getName());
if (registeredTypes.get(providerKey) != null && !deviceTypeSetForTenant.contains(
deviceType.getName())) {
deviceTypesResponse.add(deviceType);
}
} }
} }
} }
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
throw new DeviceManagementException("Error occurred while obtaining the device types.", e); throw new DeviceManagementException("Error occurred while obtaining the device types.", e);
@ -714,7 +732,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
try { try {
for (DeviceIdentifier deviceId : deviceIds) { for (DeviceIdentifier deviceId : deviceIds) {
DeviceManagementService dms = DeviceManagementService dms =
getPluginRepository().getDeviceManagementService(deviceId.getType()); getPluginRepository().getDeviceManagementService(deviceId.getType(), this.getTenantId());
dms.notifyOperationToDevices(operation, deviceIds); dms.notifyOperationToDevices(operation, deviceIds);
} }
} catch (DeviceManagementException deviceMgtEx) { } catch (DeviceManagementException deviceMgtEx) {
@ -1068,7 +1086,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
public void updateDeviceEnrolmentInfo(Device device, EnrolmentInfo.Status status) throws DeviceManagementException { public void updateDeviceEnrolmentInfo(Device device, EnrolmentInfo.Status status) throws DeviceManagementException {
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceType deviceType = deviceTypeDAO.getDeviceType(device.getType()); DeviceType deviceType = deviceTypeDAO.getDeviceType(device.getType(), this.getTenantId());
device.getEnrolmentInfo().setDateOfLastUpdate(new Date().getTime()); device.getEnrolmentInfo().setDateOfLastUpdate(new Date().getTime());
device.getEnrolmentInfo().setStatus(status); device.getEnrolmentInfo().setStatus(status);
deviceDAO.updateDevice(deviceType.getId(), device, this.getTenantId()); deviceDAO.updateDevice(deviceType.getId(), device, this.getTenantId());
@ -1171,7 +1189,7 @@ public class DeviceManagementProviderServiceImpl implements DeviceManagementProv
private DeviceManager getDeviceManager(String deviceType) { private DeviceManager getDeviceManager(String deviceType) {
DeviceManagementService deviceManagementService = DeviceManagementService deviceManagementService =
this.getPluginRepository().getDeviceManagementService(deviceType); this.getPluginRepository().getDeviceManagementService(deviceType, this.getTenantId());
if (deviceManagementService == null) { if (deviceManagementService == null) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Device type '" + deviceType + "' does not have an associated device management " + log.debug("Device type '" + deviceType + "' does not have an associated device management " +

@ -20,6 +20,7 @@ package org.wso2.carbon.device.mgt.core.util;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.w3c.dom.Document; import org.w3c.dom.Document;
import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.Device; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
@ -33,6 +34,8 @@ import org.wso2.carbon.device.mgt.core.dao.DeviceTypeDAO;
import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil; import org.wso2.carbon.device.mgt.core.dao.util.DeviceManagementDAOUtil;
import org.wso2.carbon.device.mgt.core.dto.DeviceType; import org.wso2.carbon.device.mgt.core.dto.DeviceType;
import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder; import org.wso2.carbon.device.mgt.core.internal.DeviceManagementDataHolder;
import org.wso2.carbon.user.api.TenantManager;
import org.wso2.carbon.user.api.UserStoreException;
import org.wso2.carbon.utils.CarbonUtils; import org.wso2.carbon.utils.CarbonUtils;
import org.wso2.carbon.utils.ConfigurationContextService; import org.wso2.carbon.utils.ConfigurationContextService;
import org.wso2.carbon.utils.NetworkUtils; import org.wso2.carbon.utils.NetworkUtils;
@ -100,29 +103,32 @@ public final class DeviceManagerUtil {
* Adds a new device type to the database if it does not exists. * Adds a new device type to the database if it does not exists.
* *
* @param typeName device type * @param typeName device type
* @param tenantId provider tenant Id
* @param isSharedWithAllTenants is this device type shared with all tenants.
* @return status of the operation * @return status of the operation
*/ */
public static boolean registerDeviceType(String typeName) throws DeviceManagementException { public static boolean registerDeviceType(String typeName, int tenantId, boolean isSharedWithAllTenants)
throws DeviceManagementException {
boolean status; boolean status;
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO(); DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
DeviceType deviceType = deviceTypeDAO.getDeviceType(typeName); DeviceType deviceType = deviceTypeDAO.getDeviceType(typeName, tenantId);
if (deviceType == null) { if (deviceType == null) {
DeviceType dt = new DeviceType(); deviceType = new DeviceType();
dt.setName(typeName); deviceType.setName(typeName);
deviceTypeDAO.addDeviceType(dt); deviceTypeDAO.addDeviceType(deviceType, tenantId, isSharedWithAllTenants);
} }
DeviceManagementDAOFactory.commitTransaction(); DeviceManagementDAOFactory.commitTransaction();
status = true; status = true;
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
throw new DeviceManagementException("Error occurred while registering the device type '" + throw new DeviceManagementException("Error occurred while registering the device type '"
typeName + "'", e); + typeName + "'", e);
} catch (TransactionManagementException e) { } catch (TransactionManagementException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
throw new DeviceManagementException("SQL occurred while registering the device type '" + throw new DeviceManagementException("SQL occurred while registering the device type '"
typeName + "'", e); + typeName + "'", e);
} finally { } finally {
DeviceManagementDAOFactory.closeConnection(); DeviceManagementDAOFactory.closeConnection();
} }
@ -135,26 +141,24 @@ public final class DeviceManagerUtil {
* @param typeName device type * @param typeName device type
* @return status of the operation * @return status of the operation
*/ */
public static boolean unregisterDeviceType(String typeName) throws DeviceManagementException { public static boolean unregisterDeviceType(String typeName, int tenantId) throws DeviceManagementException {
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO(); DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
DeviceType deviceType = deviceTypeDAO.getDeviceType(typeName); DeviceType deviceType = deviceTypeDAO.getDeviceType(typeName, tenantId);
if (deviceType != null) { if (deviceType != null) {
DeviceType dt = new DeviceType(); deviceTypeDAO.removeDeviceType(typeName, tenantId);
dt.setName(typeName);
deviceTypeDAO.removeDeviceType(typeName);
} }
DeviceManagementDAOFactory.commitTransaction(); DeviceManagementDAOFactory.commitTransaction();
return true; return true;
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
throw new DeviceManagementException("Error occurred while registering the device type '" + throw new DeviceManagementException("Error occurred while registering the device type '" +
typeName + "'", e); typeName + "'", e);
} catch (TransactionManagementException e) { } catch (TransactionManagementException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
throw new DeviceManagementException("SQL occurred while registering the device type '" + throw new DeviceManagementException("SQL occurred while registering the device type '" +
typeName + "'", e); typeName + "'", e);
} finally { } finally {
DeviceManagementDAOFactory.closeConnection(); DeviceManagementDAOFactory.closeConnection();
} }
@ -217,4 +221,27 @@ public final class DeviceManagerUtil {
return "http://" + hostName + ":" + port; return "http://" + hostName + ":" + port;
} }
/**
* returns the tenant Id of the specific tenant Domain
*
* @param tenantDomain
* @return
* @throws DeviceManagementException
*/
public static int getTenantId(String tenantDomain) throws DeviceManagementException {
try {
if (tenantDomain.equals(MultitenantConstants.SUPER_TENANT_DOMAIN_NAME)) {
return MultitenantConstants.SUPER_TENANT_ID;
}
TenantManager tenantManager = DeviceManagementDataHolder.getInstance().getTenantManager();
int tenantId = tenantManager.getTenantId(tenantDomain);
if (tenantId == -1) {
throw new DeviceManagementException("invalid tenant Domain :" + tenantDomain);
}
return tenantId;
} catch (UserStoreException e) {
throw new DeviceManagementException("invalid tenant Domain :" + tenantDomain);
}
}
} }

@ -27,41 +27,45 @@ import org.wso2.carbon.device.mgt.core.common.TestDataHolder;
public class DeviceManagementRepositoryTests { public class DeviceManagementRepositoryTests {
private DeviceManagementPluginRepository repository; private DeviceManagementPluginRepository repository;
@BeforeClass @BeforeClass
public void initRepository() { public void initRepository() {
this.repository = new DeviceManagementPluginRepository(); this.repository = new DeviceManagementPluginRepository();
} }
@Test @Test
public void testAddDeviceManagementService() { public void testAddDeviceManagementService() {
DeviceManagementService sourceProvider = new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE); DeviceManagementService sourceProvider = new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE,
try { TestDataHolder.SUPER_TENANT_DOMAIN);
this.getRepository().addDeviceManagementProvider(sourceProvider); try {
} catch (DeviceManagementException e) { this.getRepository().addDeviceManagementProvider(sourceProvider);
Assert.fail("Unexpected error occurred while invoking addDeviceManagementProvider functionality", e); } catch (DeviceManagementException e) {
} Assert.fail("Unexpected error occurred while invoking addDeviceManagementProvider functionality", e);
DeviceManagementService targetProvider = }
this.getRepository().getDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE); DeviceManagementService targetProvider =
Assert.assertEquals(targetProvider.getType(), sourceProvider.getType()); this.getRepository().getDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE,
} TestDataHolder.SUPER_TENANT_ID);
Assert.assertEquals(targetProvider.getType(), sourceProvider.getType());
}
@Test(dependsOnMethods = "testAddDeviceManagementService") @Test(dependsOnMethods = "testAddDeviceManagementService")
public void testRemoveDeviceManagementService() { public void testRemoveDeviceManagementService() {
DeviceManagementService sourceProvider = new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE); DeviceManagementService sourceProvider = new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE,
try { TestDataHolder.SUPER_TENANT_DOMAIN);
this.getRepository().removeDeviceManagementProvider(sourceProvider); try {
} catch (DeviceManagementException e) { this.getRepository().removeDeviceManagementProvider(sourceProvider);
Assert.fail("Unexpected error occurred while invoking removeDeviceManagementProvider functionality", e); } catch (DeviceManagementException e) {
} Assert.fail("Unexpected error occurred while invoking removeDeviceManagementProvider functionality", e);
DeviceManagementService targetProvider = }
this.getRepository().getDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE); DeviceManagementService targetProvider =
Assert.assertNull(targetProvider); this.getRepository().getDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE,
} TestDataHolder.SUPER_TENANT_ID);
Assert.assertNull(targetProvider);
}
private DeviceManagementPluginRepository getRepository() { private DeviceManagementPluginRepository getRepository() {
return repository; return repository;
} }
} }

@ -34,15 +34,25 @@ import java.util.List;
public class TestDeviceManagementService implements DeviceManagementService { public class TestDeviceManagementService implements DeviceManagementService {
private String providerType; private String providerType;
private String tenantDomain;
public TestDeviceManagementService(String deviceType){ public TestDeviceManagementService(String deviceType, String tenantDomain){
providerType = deviceType; providerType = deviceType;
this.tenantDomain = tenantDomain;
} }
@Override @Override
public String getType() { public String getType() {
return providerType; return providerType;
} }
@Override
public String getProviderTenantDomain() { return tenantDomain;}
@Override
public boolean isSharedWithAllTenants() {
return true;
}
@Override @Override
public void init() throws DeviceManagementException { public void init() throws DeviceManagementException {

@ -43,7 +43,7 @@ public class ApplicationManagementProviderServiceTest {
public void init() { public void init() {
deviceManagementPluginRepository = new DeviceManagementPluginRepository(); deviceManagementPluginRepository = new DeviceManagementPluginRepository();
TestDeviceManagementService testDeviceManagementService = TestDeviceManagementService testDeviceManagementService =
new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE); new TestDeviceManagementService(TestDataHolder.TEST_DEVICE_TYPE, TestDataHolder.SUPER_TENANT_DOMAIN);
try { try {
deviceManagementPluginRepository.addDeviceManagementProvider(testDeviceManagementService); deviceManagementPluginRepository.addDeviceManagementProvider(testDeviceManagementService);
} catch (DeviceManagementException e) { } catch (DeviceManagementException e) {

@ -31,6 +31,7 @@ public class TestDataHolder {
public static DeviceType initialTestDeviceType; public static DeviceType initialTestDeviceType;
public static String TEST_DEVICE_TYPE = "Test"; public static String TEST_DEVICE_TYPE = "Test";
public static Integer SUPER_TENANT_ID = -1234; public static Integer SUPER_TENANT_ID = -1234;
public static String SUPER_TENANT_DOMAIN="carbon.super";
public static String initialDeviceIdentifier = "12345"; public static String initialDeviceIdentifier = "12345";
public static String OWNER = "admin"; public static String OWNER = "admin";

@ -54,7 +54,7 @@ public class DevicePersistTests extends BaseDeviceManagementTest {
DeviceType deviceType = TestDataHolder.generateDeviceTypeData(TestDataHolder.TEST_DEVICE_TYPE); DeviceType deviceType = TestDataHolder.generateDeviceTypeData(TestDataHolder.TEST_DEVICE_TYPE);
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
deviceTypeDAO.addDeviceType(deviceType); deviceTypeDAO.addDeviceType(deviceType, TestDataHolder.SUPER_TENANT_ID, true);
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
String msg = "Error occurred while adding device type '" + deviceType.getName() + "'"; String msg = "Error occurred while adding device type '" + deviceType.getName() + "'";

@ -1,6 +1,8 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID INT auto_increment NOT NULL, ID INT AUTO_INCREMENT NOT NULL,
NAME VARCHAR(300) DEFAULT NULL, NAME VARCHAR(300) NULL DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID) PRIMARY KEY (ID)
); );

@ -125,7 +125,7 @@
javax.servlet;resolution:=optional, javax.servlet;resolution:=optional,
javax.xml.*;resolution:=optional, javax.xml.*;resolution:=optional,
org.apache.commons.lang, org.apache.commons.lang,
javax.ws.rs;resolution:=optional, javax.ws.rs;version="0.0.0";resolution:=optional,
org.scannotation org.scannotation
</Import-Package> </Import-Package>
</instructions> </instructions>

@ -39,7 +39,6 @@
<module>org.wso2.carbon.device.mgt.common</module> <module>org.wso2.carbon.device.mgt.common</module>
<module>org.wso2.carbon.device.mgt.extensions</module> <module>org.wso2.carbon.device.mgt.extensions</module>
<module>org.wso2.carbon.device.mgt.ui</module> <module>org.wso2.carbon.device.mgt.ui</module>
<module>org.wso2.carbon.device.mgt.analytics</module>
<module>org.wso2.carbon.device.mgt.analytics.data.publisher</module> <module>org.wso2.carbon.device.mgt.analytics.data.publisher</module>
<module>org.wso2.carbon.device.mgt.etc</module> <module>org.wso2.carbon.device.mgt.etc</module>
</modules> </modules>

@ -133,10 +133,10 @@
<Bundle-Name>${project.artifactId}</Bundle-Name> <Bundle-Name>${project.artifactId}</Bundle-Name>
<Bundle-Version>${carbon.device.mgt.version}</Bundle-Version> <Bundle-Version>${carbon.device.mgt.version}</Bundle-Version>
<Bundle-Description>Device Management JWT Client Bundle</Bundle-Description> <Bundle-Description>Device Management JWT Client Bundle</Bundle-Description>
<Private-Package>org.wso2.carbon.device.mgt.jwt.client.extension.internal</Private-Package> <Private-Package>org.wso2.carbon.identity.jwt.client.extension.internal</Private-Package>
<Export-Package> <Export-Package>
!org.wso2.carbon.device.mgt.jwt.client.extension.internal, !org.wso2.carbon.identity.jwt.client.extension.internal,
org.wso2.carbon.device.mgt.jwt.client.extension.* org.wso2.carbon.identity.jwt.client.extension.*
</Export-Package> </Export-Package>
<Import-Package> <Import-Package>
org.osgi.framework, org.osgi.framework,

@ -16,7 +16,7 @@
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension; package org.wso2.carbon.identity.jwt.client.extension;
import com.nimbusds.jose.JOSEException; import com.nimbusds.jose.JOSEException;
import com.nimbusds.jose.JWSAlgorithm; import com.nimbusds.jose.JWSAlgorithm;
@ -39,11 +39,11 @@ import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException; import org.json.simple.parser.ParseException;
import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.core.util.KeyStoreManager; import org.wso2.carbon.core.util.KeyStoreManager;
import org.wso2.carbon.device.mgt.jwt.client.extension.constant.JWTConstants; import org.wso2.carbon.identity.jwt.client.extension.constant.JWTConstants;
import org.wso2.carbon.device.mgt.jwt.client.extension.dto.AccessTokenInfo; import org.wso2.carbon.identity.jwt.client.extension.dto.AccessTokenInfo;
import org.wso2.carbon.device.mgt.jwt.client.extension.dto.JWTConfig; import org.wso2.carbon.identity.jwt.client.extension.dto.JWTConfig;
import org.wso2.carbon.device.mgt.jwt.client.extension.exception.JWTClientException; import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientException;
import org.wso2.carbon.device.mgt.jwt.client.extension.util.JWTClientUtil; import org.wso2.carbon.identity.jwt.client.extension.util.JWTClientUtil;
import java.io.File; import java.io.File;
import java.io.IOException; import java.io.IOException;

@ -16,17 +16,17 @@
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension; package org.wso2.carbon.identity.jwt.client.extension;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.CarbonContext; import org.wso2.carbon.context.CarbonContext;
import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.jwt.client.extension.dto.JWTConfig; import org.wso2.carbon.identity.jwt.client.extension.dto.JWTConfig;
import org.wso2.carbon.device.mgt.jwt.client.extension.exception.JWTClientAlreadyExistsException; import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientAlreadyExistsException;
import org.wso2.carbon.device.mgt.jwt.client.extension.exception.JWTClientConfigurationException; import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientConfigurationException;
import org.wso2.carbon.device.mgt.jwt.client.extension.exception.JWTClientException; import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientException;
import org.wso2.carbon.device.mgt.jwt.client.extension.util.JWTClientUtil; import org.wso2.carbon.identity.jwt.client.extension.util.JWTClientUtil;
import org.wso2.carbon.registry.core.Resource; import org.wso2.carbon.registry.core.Resource;
import org.wso2.carbon.registry.core.exceptions.RegistryException; import org.wso2.carbon.registry.core.exceptions.RegistryException;

@ -15,7 +15,7 @@
* specific language governing permissions and limitations * specific language governing permissions and limitations
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.constant; package org.wso2.carbon.identity.jwt.client.extension.constant;
/** /**
* This holds the constants related JWT client component. * This holds the constants related JWT client component.

@ -16,7 +16,7 @@
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.dto; package org.wso2.carbon.identity.jwt.client.extension.dto;
/** /**
* This holds the token information that return from the token endpoint. * This holds the token information that return from the token endpoint.

@ -1,4 +1,4 @@
package org.wso2.carbon.device.mgt.jwt.client.extension.dto; package org.wso2.carbon.identity.jwt.client.extension.dto;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;

@ -17,7 +17,7 @@
* *
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.exception; package org.wso2.carbon.identity.jwt.client.extension.exception;
public class JWTClientAlreadyExistsException extends Exception { public class JWTClientAlreadyExistsException extends Exception {
public JWTClientAlreadyExistsException() { public JWTClientAlreadyExistsException() {

@ -16,7 +16,7 @@
* under the License. * under the License.
* *
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.exception; package org.wso2.carbon.identity.jwt.client.extension.exception;
public class JWTClientConfigurationException extends Exception { public class JWTClientConfigurationException extends Exception {
public JWTClientConfigurationException() { public JWTClientConfigurationException() {

@ -16,7 +16,7 @@
* under the License. * under the License.
* *
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.exception; package org.wso2.carbon.identity.jwt.client.extension.exception;
public class JWTClientException extends Exception{ public class JWTClientException extends Exception{
public JWTClientException() { public JWTClientException() {

@ -16,7 +16,7 @@
* under the License. * under the License.
* *
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.internal; package org.wso2.carbon.identity.jwt.client.extension.internal;
import org.wso2.carbon.registry.core.service.RegistryService; import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.registry.core.service.TenantRegistryLoader; import org.wso2.carbon.registry.core.service.TenantRegistryLoader;

@ -16,12 +16,12 @@
* under the License. * under the License.
* *
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.internal; package org.wso2.carbon.identity.jwt.client.extension.internal;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext; import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.device.mgt.jwt.client.extension.util.JWTClientUtil; import org.wso2.carbon.identity.jwt.client.extension.util.JWTClientUtil;
import org.wso2.carbon.registry.core.exceptions.RegistryException; import org.wso2.carbon.registry.core.exceptions.RegistryException;
import org.wso2.carbon.registry.core.service.RegistryService; import org.wso2.carbon.registry.core.service.RegistryService;
import org.wso2.carbon.registry.core.service.TenantRegistryLoader; import org.wso2.carbon.registry.core.service.TenantRegistryLoader;
@ -30,7 +30,7 @@ import org.wso2.carbon.user.core.service.RealmService;
import java.io.IOException; import java.io.IOException;
/** /**
* @scr.component name="org.wso2.carbon.device.mgt.jwt.client.extension.internal.JWTClientExtensionServiceComponent" * @scr.component name="org.wso2.carbon.identity.jwt.client.extension.internal.JWTClientExtensionServiceComponent"
* immediate="true" * immediate="true"
* @scr.reference name="registry.service" * @scr.reference name="registry.service"
* interface="org.wso2.carbon.registry.core.service.RegistryService" * interface="org.wso2.carbon.registry.core.service.RegistryService"

@ -15,7 +15,7 @@
* specific language governing permissions and limitations * specific language governing permissions and limitations
* under the License. * under the License.
*/ */
package org.wso2.carbon.device.mgt.jwt.client.extension.util; package org.wso2.carbon.identity.jwt.client.extension.util;
import org.apache.commons.io.FileUtils; import org.apache.commons.io.FileUtils;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
@ -29,7 +29,7 @@ import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils; import org.apache.http.util.EntityUtils;
import org.wso2.carbon.base.MultitenantConstants; import org.wso2.carbon.base.MultitenantConstants;
import org.wso2.carbon.context.PrivilegedCarbonContext; import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.jwt.client.extension.internal.JWTClientExtensionDataHolder; import org.wso2.carbon.identity.jwt.client.extension.internal.JWTClientExtensionDataHolder;
import org.wso2.carbon.registry.core.Registry; import org.wso2.carbon.registry.core.Registry;
import org.wso2.carbon.registry.core.Resource; import org.wso2.carbon.registry.core.Resource;
import org.wso2.carbon.registry.core.exceptions.RegistryException; import org.wso2.carbon.registry.core.exceptions.RegistryException;

@ -21,6 +21,7 @@ package org.wso2.carbon.policy.mgt.core.mgt.impl;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.common.Device; import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier; import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
@ -375,7 +376,8 @@ public class MonitoringManagerImpl implements MonitoringManager {
List<DeviceType> deviceTypes = new ArrayList<>(); List<DeviceType> deviceTypes = new ArrayList<>();
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
deviceTypes = deviceTypeDAO.getDeviceTypes(); int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
deviceTypes = deviceTypeDAO.getDeviceTypes(tenantId);
} catch (Exception e) { } catch (Exception e) {
log.error("Error occurred while getting the device types.", e); log.error("Error occurred while getting the device types.", e);
} finally { } finally {

@ -20,6 +20,7 @@ package org.wso2.carbon.policy.mgt.core.mgt.impl;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.core.dao.DeviceDAO; import org.wso2.carbon.device.mgt.core.dao.DeviceDAO;
import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException; import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOException;
import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory; import org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOFactory;
@ -184,8 +185,9 @@ public class ProfileManagerImpl implements ProfileManager {
List<DeviceType> deviceTypes; List<DeviceType> deviceTypes;
try { try {
int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
deviceTypes = deviceTypeDAO.getDeviceTypes(); deviceTypes = deviceTypeDAO.getDeviceTypes(tenantId);
} catch (SQLException e) { } catch (SQLException e) {
throw new ProfileManagementException("Error occurred while opening a connection to the data source", e); throw new ProfileManagementException("Error occurred while opening a connection to the data source", e);
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
@ -236,7 +238,8 @@ public class ProfileManagerImpl implements ProfileManager {
try { try {
DeviceManagementDAOFactory.openConnection(); DeviceManagementDAOFactory.openConnection();
deviceType = deviceTypeDAO.getDeviceType(deviceTypeName); int tenantId = PrivilegedCarbonContext.getThreadLocalCarbonContext().getTenantId();
deviceType = deviceTypeDAO.getDeviceType(deviceTypeName, tenantId);
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
throw new ProfileManagementException("Error occurred while retrieving device type information", e); throw new ProfileManagementException("Error occurred while retrieving device type information", e);
} catch (SQLException e) { } catch (SQLException e) {

@ -60,7 +60,7 @@ public class PolicyDAOTestCase extends BasePolicyManagementDAOTest {
try { try {
DeviceManagementDAOFactory.beginTransaction(); DeviceManagementDAOFactory.beginTransaction();
DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO(); DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
deviceTypeDAO.addDeviceType(DeviceTypeCreator.getDeviceType()); deviceTypeDAO.addDeviceType(DeviceTypeCreator.getDeviceType(), -1234, true);
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
DeviceManagementDAOFactory.rollbackTransaction(); DeviceManagementDAOFactory.rollbackTransaction();
throw new DeviceManagementDAOException("Error occurred while adding dummy device type", e); throw new DeviceManagementDAOException("Error occurred while adding dummy device type", e);

@ -1,6 +1,8 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID INT auto_increment NOT NULL, ID INT AUTO_INCREMENT NOT NULL,
NAME VARCHAR(300) NULL DEFAULT NULL, NAME VARCHAR(300) NULL DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID) PRIMARY KEY (ID)
); );

@ -25,6 +25,8 @@ DROP TABLE IF EXISTS `WSO2CDM`.`DM_DEVICE_TYPE` ;
CREATE TABLE IF NOT EXISTS `WSO2CDM`.`DM_DEVICE_TYPE` ( CREATE TABLE IF NOT EXISTS `WSO2CDM`.`DM_DEVICE_TYPE` (
`ID` INT(11) NOT NULL AUTO_INCREMENT, `ID` INT(11) NOT NULL AUTO_INCREMENT,
`NAME` VARCHAR(300) NULL DEFAULT NULL, `NAME` VARCHAR(300) NULL DEFAULT NULL,
`PROVIDER_TENANT_ID` INTEGER DEFAULT 0,
`SHARED_WITH_ALL_TENANTS` BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (`ID`)) PRIMARY KEY (`ID`))
ENGINE = InnoDB ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1; DEFAULT CHARACTER SET = latin1;

@ -26,6 +26,7 @@ import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.tomcat.ext.valves.CarbonTomcatValve; import org.wso2.carbon.tomcat.ext.valves.CarbonTomcatValve;
import org.wso2.carbon.tomcat.ext.valves.CompositeValve; import org.wso2.carbon.tomcat.ext.valves.CompositeValve;
import org.wso2.carbon.webapp.authenticator.framework.authenticator.WebappAuthenticator; import org.wso2.carbon.webapp.authenticator.framework.authenticator.WebappAuthenticator;
import org.wso2.carbon.webapp.authenticator.framework.authorizer.WebappTenantAuthorizer;
import javax.servlet.http.HttpServletResponse; import javax.servlet.http.HttpServletResponse;
import java.util.HashMap; import java.util.HashMap;
@ -44,6 +45,8 @@ public class WebappAuthenticationValve extends CarbonTomcatValve {
return; return;
} }
WebappAuthenticator authenticator = WebappAuthenticatorFactory.getAuthenticator(request); WebappAuthenticator authenticator = WebappAuthenticatorFactory.getAuthenticator(request);
if (authenticator == null) { if (authenticator == null) {
String msg = "Failed to load an appropriate authenticator to authenticate the request"; String msg = "Failed to load an appropriate authenticator to authenticate the request";
@ -51,6 +54,11 @@ public class WebappAuthenticationValve extends CarbonTomcatValve {
return; return;
} }
AuthenticationInfo authenticationInfo = authenticator.authenticate(request, response); AuthenticationInfo authenticationInfo = authenticator.authenticate(request, response);
if (isManagedAPI(request) && (authenticationInfo.getStatus() == WebappAuthenticator.Status.CONTINUE ||
authenticationInfo.getStatus() == WebappAuthenticator.Status.SUCCESS)) {
WebappAuthenticator.Status status = WebappTenantAuthorizer.authorize(request, authenticationInfo);
authenticationInfo.setStatus(status);
}
if (authenticationInfo.getTenantId() != -1) { if (authenticationInfo.getTenantId() != -1) {
try { try {
PrivilegedCarbonContext.startTenantFlow(); PrivilegedCarbonContext.startTenantFlow();
@ -77,6 +85,11 @@ public class WebappAuthenticationValve extends CarbonTomcatValve {
return (param == null || !Boolean.parseBoolean(param) || isNonSecuredEndPoint(request)); return (param == null || !Boolean.parseBoolean(param) || isNonSecuredEndPoint(request));
} }
private boolean isManagedAPI(Request request) {
String param = request.getContext().findParameter("managed-api-enabled");
return (param != null && Boolean.parseBoolean(param));
}
private boolean isContextSkipped(Request request) { private boolean isContextSkipped(Request request) {
String ctx = request.getContext().getPath(); String ctx = request.getContext().getPath();
if (ctx == null || "".equals(ctx)) { if (ctx == null || "".equals(ctx)) {

@ -0,0 +1,49 @@
/*
* Copyright (c) 2015, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* WSO2 Inc. licenses this file to you under the Apache License,
* Version 2.0 (the "License"); you may not use this file except
* in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing,
* software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
* KIND, either express or implied. See the License for the
* specific language governing permissions and limitations
* under the License.
*/
package org.wso2.carbon.webapp.authenticator.framework.authorizer;
import org.apache.catalina.connector.Request;
import org.wso2.carbon.webapp.authenticator.framework.AuthenticationInfo;
import org.wso2.carbon.webapp.authenticator.framework.authenticator.WebappAuthenticator;
/**
* This class represents the methods that are used to authorize requests based on the tenant subscription.
*/
public class WebappTenantAuthorizer {
private static final String SHARED_WITH_ALL_TENANTS_PARAM_NAME = "isSharedWithAllTenants";
private static final String PROVIDER_TENANT_DOMAIN_PARAM_NAME = "providerTenantDomain";
public static WebappAuthenticator.Status authorize(Request request, AuthenticationInfo authenticationInfo) {
String tenantDomain = authenticationInfo.getTenantDomain();
if (tenantDomain != null && isSharedWithAllTenants(request) || isProviderTenant(request, tenantDomain)) {
return WebappAuthenticator.Status.CONTINUE;
}
return WebappAuthenticator.Status.FAILURE;
}
private static boolean isSharedWithAllTenants(Request request) {
String param = request.getContext().findParameter(SHARED_WITH_ALL_TENANTS_PARAM_NAME);
return (param == null || Boolean.parseBoolean(param));
}
private static boolean isProviderTenant(Request request, String requestTenantDomain) {
String param = request.getContext().findParameter(PROVIDER_TENANT_DOMAIN_PARAM_NAME);
return (param == null || requestTenantDomain.equals(param));
}
}

@ -0,0 +1,134 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
~
~ WSO2 Inc. licenses this file to you under the Apache License,
~ Version 2.0 (the "License"); you may not use this file except
~ in compliance with the License.
~ You may obtain a copy of the License at
~
~ http://www.apache.org/licenses/LICENSE-2.0
~
~ Unless required by applicable law or agreed to in writing,
~ software distributed under the License is distributed on an
~ "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
~ KIND, either express or implied. See the License for the
~ specific language governing permissions and limitations
~ under the License.
-->
<project xmlns="http://maven.apache.org/POM/4.0.0"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<parent>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>apimgt-extensions-feature</artifactId>
<version>1.1.0-SNAPSHOT</version>
<relativePath>../pom.xml</relativePath>
</parent>
<modelVersion>4.0.0</modelVersion>
<artifactId>org.wso2.carbon.apimgt.application.extension.feature</artifactId>
<packaging>pom</packaging>
<version>1.1.0-SNAPSHOT</version>
<name>WSO2 Carbon - API Management Application Extension Feature</name>
<url>http://wso2.org</url>
<description>This feature contains an implementation of a api application registration, which takes care of subscription
and generating keys.
</description>
<dependencies>
<dependency>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.apimgt.application.extension</artifactId>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<artifactId>maven-resources-plugin</artifactId>
<version>2.6</version>
<executions>
<execution>
<id>copy-resources</id>
<phase>generate-resources</phase>
<goals>
<goal>copy-resources</goal>
</goals>
<configuration>
<outputDirectory>src/main/resources</outputDirectory>
<resources>
<resource>
<directory>resources</directory>
<includes>
<include>build.properties</include>
<include>p2.inf</include>
</includes>
</resource>
</resources>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-dependency-plugin</artifactId>
<executions>
<execution>
<id>copy-jaxrs-war</id>
<phase>package</phase>
<goals>
<goal>copy</goal>
</goals>
<configuration>
<artifactItems>
<artifactItem>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.apimgt.application.extension.api</artifactId>
<type>war</type>
<overWrite>true</overWrite>
<outputDirectory>${project.build.directory}/maven-shared-archive-resources/webapps/</outputDirectory>
<destFileName>api-application-registration.war</destFileName>
</artifactItem>
</artifactItems>
</configuration>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.wso2.maven</groupId>
<artifactId>carbon-p2-plugin</artifactId>
<version>${carbon.p2.plugin.version}</version>
<executions>
<execution>
<id>p2-feature-generation</id>
<phase>package</phase>
<goals>
<goal>p2-feature-gen</goal>
</goals>
<configuration>
<id>org.wso2.carbon.apimgt.application.extension</id>
<propertiesFile>../../../features/etc/feature.properties</propertiesFile>
<adviceFile>
<properties>
<propertyDef>org.wso2.carbon.p2.category.type:server</propertyDef>
<propertyDef>org.eclipse.equinox.p2.type.group:false</propertyDef>
</properties>
</adviceFile>
<bundles>
<bundleDef>
org.wso2.carbon.devicemgt:org.wso2.carbon.apimgt.application.extension:${carbon.device.mgt.version}
</bundleDef>
</bundles>
<importFeatures>
<importFeatureDef>org.wso2.carbon.core.server:${carbon.kernel.version}</importFeatureDef>
</importFeatures>
</configuration>
</execution>
</executions>
</plugin>
</plugins>
</build>
</project>

@ -0,0 +1,3 @@
instructions.configure = \
org.eclipse.equinox.p2.touchpoint.natives.mkdir(path:${installFolder}/../../deployment/server/webapps/);\
org.eclipse.equinox.p2.touchpoint.natives.copy(source:${installFolder}/../features/org.wso2.carbon.apimgt.application.extension_${feature.version}/webapps/,target:${installFolder}/../../deployment/server/webapps/,overwrite:true);\

@ -36,6 +36,7 @@
<modules> <modules>
<module>org.wso2.carbon.apimgt.webapp.publisher.feature</module> <module>org.wso2.carbon.apimgt.webapp.publisher.feature</module>
<module>org.wso2.carbon.apimgt.application.extension.feature</module>
</modules> </modules>
</project> </project>

@ -1,2 +1,2 @@
instructions.configure = \ instructions.configure = \
org.eclipse.equinox.p2.touchpoint.natives.copy(source:${installFolder}/../features/org.wso2.carbon.device.mgt.server_${feature.version}/conf/device-analytics-config.xml,target:${installFolder}/../../conf/etc/device-analytics-config.xml,overwrite:true);\ org.eclipse.equinox.p2.touchpoint.natives.copy(source:${installFolder}/../features/org.wso2.carbon.device.mgt.analytics.data.publisher_${feature.version}/conf/device-analytics-config.xml,target:${installFolder}/../../conf/etc/device-analytics-config.xml,overwrite:true);\

@ -1,6 +1,8 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID INT auto_increment NOT NULL, ID INT AUTO_INCREMENT NOT NULL,
NAME VARCHAR(300) DEFAULT NULL, NAME VARCHAR(300) NULL DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID) PRIMARY KEY (ID)
); );

@ -1,7 +1,9 @@
CREATE TABLE DM_DEVICE_TYPE ( CREATE TABLE DM_DEVICE_TYPE (
ID INTEGER IDENTITY NOT NULL, ID INTEGER IDENTITY NOT NULL,
NAME VARCHAR(300) DEFAULT NULL, NAME VARCHAR(300) DEFAULT NULL,
PRIMARY KEY (ID) PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID)
); );
CREATE TABLE DM_DEVICE_CERTIFICATE ( CREATE TABLE DM_DEVICE_CERTIFICATE (

@ -1,6 +1,8 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID INTEGER AUTO_INCREMENT NOT NULL, ID INTEGER AUTO_INCREMENT NOT NULL,
NAME VARCHAR(300) DEFAULT NULL, NAME VARCHAR(300) DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
PRIMARY KEY (ID) PRIMARY KEY (ID)
)ENGINE = InnoDB; )ENGINE = InnoDB;

@ -1,6 +1,8 @@
CREATE TABLE DM_DEVICE_TYPE ( CREATE TABLE DM_DEVICE_TYPE (
ID NUMBER(10) NOT NULL, ID NUMBER(10) NOT NULL,
NAME VARCHAR2(300) DEFAULT NULL, NAME VARCHAR2(300) DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE,
CONSTRAINT PK_DM_DEVICE_TYPE PRIMARY KEY (ID) CONSTRAINT PK_DM_DEVICE_TYPE PRIMARY KEY (ID)
) )
/ /

@ -1,6 +1,8 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE (
ID BIGSERIAL PRIMARY KEY, ID BIGSERIAL PRIMARY KEY,
NAME VARCHAR(300) DEFAULT NULL NAME VARCHAR(300) DEFAULT NULL,
PROVIDER_TENANT_ID INTEGER DEFAULT 0,
SHARED_WITH_ALL_TENANTS BOOLEAN NOT NULL DEFAULT FALSE
); );
CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE ( CREATE TABLE IF NOT EXISTS DM_DEVICE_CERTIFICATE (

@ -445,6 +445,11 @@
</exclusion> </exclusion>
</exclusions> </exclusions>
</dependency> </dependency>
<dependency>
<groupId>org.wso2.carbon.governance</groupId>
<artifactId>org.wso2.carbon.governance.lcm</artifactId>
<version>${carbon.governance.version}</version>
</dependency>
<!-- End of Governance dependencies --> <!-- End of Governance dependencies -->
<!-- OSGi dependencies--> <!-- OSGi dependencies-->
@ -1722,8 +1727,8 @@
<carbon.analytics.common.version.range>[5.0.11,6.0.0)</carbon.analytics.common.version.range> <carbon.analytics.common.version.range>[5.0.11,6.0.0)</carbon.analytics.common.version.range>
<!-- Carbon Analytics --> <!-- Carbon Analytics -->
<carbon.analytics.version>1.0.6-SNAPSHOT</carbon.analytics.version> <carbon.analytics.version>1.0.5</carbon.analytics.version>
<carbon.analytics.version.range>[1.0.6,2.0.0]</carbon.analytics.version.range> <carbon.analytics.version.range>[1.0.5,2.0.0]</carbon.analytics.version.range>
<!-- Carbon Registry --> <!-- Carbon Registry -->
<carbon.registry.version>4.4.8</carbon.registry.version> <carbon.registry.version>4.4.8</carbon.registry.version>

Loading…
Cancel
Save