fixed analytics multi tenant issues

revert-dabc3590
ayyoob 8 years ago
parent 73eb590a7c
commit 50d8aedade

@ -19,10 +19,8 @@
<eventReceiver name="android_sense_receiver" statistics="disable" trace="disable" xmlns="http://wso2.org/carbon/eventreceiver">
<from eventAdapterType="oauth-mqtt">
<property name="topic">carbon.super/android_sense/+/data</property>
<property name="username">admin</property>
<property name="password">admin</property>
<property name="contentValidator">org.wso2.carbon.device.mgt.input.adapter.mqtt.util.MQTTContentValidator</property>
<property name="topic">${tenant-domain}/android_sense/+/data</property>
<property name="contentValidator">iot-mqtt</property>
<property name="cleanSession">true</property>
</from>
<mapping customMapping="disable" type="json"/>

@ -18,7 +18,7 @@
-->
<eventReceiver name="arduino_receiver" statistics="disable" trace="disable" xmlns="http://wso2.org/carbon/eventreceiver">
<from eventAdapterType="oauth-http">
<property name="contentValidator">org.wso2.carbon.device.mgt.input.adapter.http.util.HTTPContentValidator</property>
<property name="contentValidator">iot-http</property>
</from>
<mapping customMapping="disable" type="json"/>
<to streamName="org.wso2.iot.arduino" version="1.0.0"/>

@ -18,10 +18,8 @@
-->
<eventReceiver name="raspberrypi_receiver" statistics="disable" trace="disable" xmlns="http://wso2.org/carbon/eventreceiver">
<from eventAdapterType="oauth-mqtt">
<property name="topic">carbon.super/raspberrypi/+/temperature</property>
<property name="username">admin</property>
<property name="password">admin</property>
<property name="contentValidator">org.wso2.carbon.device.mgt.input.adapter.mqtt.util.MQTTContentValidator</property>
<property name="topic">${tenant-domain}/raspberrypi/+/temperature</property>
<property name="contentValidator">iot-mqtt</property>
<property name="cleanSession">true</property>
</from>
<mapping customMapping="disable" type="json"/>

@ -18,10 +18,8 @@
-->
<eventReceiver name="virtualfirealarm_receiver" statistics="disable" trace="disable" xmlns="http://wso2.org/carbon/eventreceiver">
<from eventAdapterType="oauth-mqtt">
<property name="topic">carbon.super/virtual_firealarm/+/temperature</property>
<property name="username">admin</property>
<property name="password">admin</property>
<property name="contentValidator">org.wso2.carbon.device.mgt.input.adapter.mqtt.util.MQTTContentValidator</property>
<property name="topic">${tenant-domain}/virtual_firealarm/+/temperature</property>
<property name="contentValidator">iot-mqtt</property>
<property name="cleanSession">true</property>
</from>
<mapping customMapping="disable" type="json"/>

@ -33,6 +33,18 @@
<build>
<plugins>
<plugin>
<groupId>org.apache.felix</groupId>
<artifactId>maven-scr-plugin</artifactId>
<executions>
<execution>
<id>generate-scr-descriptor</id>
<goals>
<goal>scr</goal>
</goals>
</execution>
</executions>
</plugin>
<plugin>
<groupId>org.apache.maven.plugins</groupId>
<artifactId>maven-surefire-plugin</artifactId>
@ -45,12 +57,48 @@
<instructions>
<Bundle-SymbolicName>${project.artifactId}</Bundle-SymbolicName>
<Bundle-Name>${project.artifactId}</Bundle-Name>
<Private-Package>
org.wso2.carbon.device.mgt.input.adapter.extension.internal,
org.wso2.carbon.device.mgt.input.adapter.extension.internal.*
</Private-Package>
<Export-Package>
org.wso2.carbon.device.mgt.input.adapter.extension.*
org.wso2.carbon.device.mgt.input.adapter.extension.*,
!org.wso2.carbon.device.mgt.input.adapter.extension.internal,
</Export-Package>
<Import-Package>
org.osgi.framework,
org.osgi.service.component,
com.jayway.jsonpath,
org.apache.commons.logging,
org.json.simple,
org.json.simple.parser
</Import-Package>
</instructions>
</configuration>
</plugin>
</plugins>
</build>
<dependencies>
<dependency>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.logging</artifactId>
</dependency>
<dependency>
<groupId>com.googlecode.json-simple.wso2</groupId>
<artifactId>json-simple</artifactId>
</dependency>
<dependency>
<groupId>com.jayway.jsonpath</groupId>
<artifactId>json-path</artifactId>
</dependency>
<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>
</dependencies>
</project>

@ -25,6 +25,11 @@ import java.util.Map;
*/
public interface ContentTransformer {
/**
* This returns the type of ContentTransformer.
*/
String getType();
/**
* This is used to transform the receiver content
* @param message message to be format

@ -24,6 +24,13 @@ import java.util.Map;
* This interface will be triggered to validate the stream content before publishing.
*/
public interface ContentValidator {
/**
* this returns the unique name of ContentValidatorType.
* @return
*/
String getType();
/**
* @param dynamicParameter that message.
* @return ContentInfo.

@ -0,0 +1,34 @@
package org.wso2.carbon.device.mgt.input.adapter.extension;
/**
* This hold the input adapter extension service.
*/
public interface InputAdapterExtensionService {
/**
* return content validator for the given type.
* @param type type of the content validator
* @return content validator for the given type.
*/
ContentValidator getContentValidator(String type);
/**
* return default content validator for the given type.
* @return default content validator for the given type.
*/
ContentValidator getDefaultContentValidator();
/**
* return content transformer for the given type.
* @param type of the content transfomer
* @return content transformer for the given type.
*/
ContentTransformer getContentTransformer(String type);
/**
* return default content transformer for the given type.
* @return default content transformer for the given type.
*/
ContentTransformer getDefaultContentTransformer();
}

@ -0,0 +1,31 @@
package org.wso2.carbon.device.mgt.input.adapter.extension;
import org.wso2.carbon.device.mgt.input.adapter.extension.internal.InputAdapterServiceDataHolder;
/**
* This hold the input adapter extension service implementation.
*/
public class InputAdapterExtensionServiceImpl implements InputAdapterExtensionService {
private static final String DEFAULT = "default";
@Override
public ContentValidator getContentValidator(String type) {
return InputAdapterServiceDataHolder.getInstance().getContentValidatorMap().get(type);
}
@Override
public ContentValidator getDefaultContentValidator() {
return InputAdapterServiceDataHolder.getInstance().getContentValidatorMap().get(DEFAULT);
}
@Override
public ContentTransformer getContentTransformer(String type) {
return InputAdapterServiceDataHolder.getInstance().getContentTransformerMap().get(type);
}
@Override
public ContentTransformer getDefaultContentTransformer() {
return InputAdapterServiceDataHolder.getInstance().getContentTransformerMap().get(DEFAULT);
}
}

@ -0,0 +1,96 @@
/*
* 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.device.mgt.input.adapter.extension.internal;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionServiceImpl;
import org.wso2.carbon.device.mgt.input.adapter.extension.transformer.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.validator.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.validator.HTTPContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.validator.MQTTContentValidator;
/**
* @scr.component name="input.adapter.extension.adapterService.component" immediate="true"
* @scr.reference name="InputAdapterServiceComponent.service"
* interface="org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator"
* cardinality="0..n"
* policy="dynamic"
* bind="setContentValidator"
* unbind="unsetContentValidator"
* * @scr.reference name="InputAdapterServiceComponent.service"
* interface="org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer"
* cardinality="0..n"
* policy="dynamic"
* bind="setContentTransformer"
* unbind="unsetContentTransformer"
*/
public class InputAdapterServiceComponent {
private static final Log log = LogFactory.getLog(
InputAdapterServiceComponent.class);
protected void activate(ComponentContext context) {
try {
if (log.isDebugEnabled()) {
log.debug("Successfully deployed the input adapter extension service");
}
InputAdapterServiceDataHolder.getInstance().addContentTransformer(new DefaultContentTransformer());
InputAdapterServiceDataHolder.getInstance().addContentValidator(new DefaultContentValidator());
InputAdapterServiceDataHolder.getInstance().addContentValidator(new HTTPContentValidator());
InputAdapterServiceDataHolder.getInstance().addContentValidator(new MQTTContentValidator());
context.getBundleContext().registerService(InputAdapterExtensionService.class,
new InputAdapterExtensionServiceImpl(), null);
} catch (RuntimeException e) {
log.error("Can not create the input adapter service ", e);
}
}
protected void setContentValidator(ContentValidator contentValidator) {
if (log.isDebugEnabled()) {
log.debug("Setting ContentValidator Service");
}
InputAdapterServiceDataHolder.getInstance().addContentValidator(contentValidator);
}
protected void unsetContentValidator(ContentValidator contentValidator) {
if (log.isDebugEnabled()) {
log.debug("Un-setting ContentValidator Service");
}
}
protected void setContentTransformer(ContentTransformer contentTransformer) {
if (log.isDebugEnabled()) {
log.debug("Setting contentTransformer Service");
}
InputAdapterServiceDataHolder.getInstance().addContentTransformer(contentTransformer);
}
protected void unsetContentValidator(ContentTransformer contentTransformer) {
if (log.isDebugEnabled()) {
log.debug("Un-setting ContentTransformer Service");
}
}
}

@ -0,0 +1,54 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.extension.internal;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import java.util.HashMap;
import java.util.Map;
/**
* common place to hold some OSGI service references.
*/
public class InputAdapterServiceDataHolder {
private static InputAdapterServiceDataHolder inputAdapterServiceDataHolder = new InputAdapterServiceDataHolder();
private static Map<String, ContentValidator> contentValidatorMap = new HashMap<>();
private static Map<String, ContentTransformer> contentTransformerMap = new HashMap<>();
private InputAdapterServiceDataHolder() {
}
public static InputAdapterServiceDataHolder getInstance() {
return inputAdapterServiceDataHolder;
}
public Map<String, ContentValidator> getContentValidatorMap() {
return contentValidatorMap;
}
public void addContentValidator(ContentValidator contentValidator) {
InputAdapterServiceDataHolder.contentValidatorMap.put(contentValidator.getType(), contentValidator);
}
public Map<String, ContentTransformer> getContentTransformerMap() {
return contentTransformerMap;
}
public void addContentTransformer(ContentTransformer contentTransformer) {
InputAdapterServiceDataHolder.contentTransformerMap.put(contentTransformer.getType(), contentTransformer);
}
}

@ -16,14 +16,22 @@
* under the License.
*/
package org.wso2.carbon.device.mgt.input.adapter.extension;
package org.wso2.carbon.device.mgt.input.adapter.extension.transformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import java.util.Map;
/**
* This holds the default implementation of ContentTransformer
*/
public class DefaultContentTransformer implements ContentTransformer{
public class DefaultContentTransformer implements ContentTransformer {
private static final String DEFAULT_CONTENT_VALIDATOR = "default";
@Override
public String getType() {
return DEFAULT_CONTENT_VALIDATOR;
}
@Override
public Object transform(Object message, Map<String, Object> dynamicProperties) {

@ -16,7 +16,10 @@
* under the License.
*/
package org.wso2.carbon.device.mgt.input.adapter.extension;
package org.wso2.carbon.device.mgt.input.adapter.extension.validator;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import java.util.Map;
@ -24,6 +27,12 @@ import java.util.Map;
* This holds the default implementation of content validator interface.
*/
public class DefaultContentValidator implements ContentValidator {
private static final String DEFAULT_TYPE = "default";
@Override
public String getType() {
return DEFAULT_TYPE;
}
@Override
public ContentInfo validate(Object message, Map<String, Object> dynamicParams) {

@ -0,0 +1,87 @@
/*
* 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.input.adapter.extension.validator;
import com.jayway.jsonpath.JsonPath;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.simple.JSONArray;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import java.util.List;
import java.util.Map;
public class HTTPContentValidator implements ContentValidator {
private static final Log log = LogFactory.getLog(HTTPContentValidator.class);
private static String JSON_ARRAY_START_CHAR = "[";
private static String CDMF_SCOPE_PREFIX = "cdmf";
private static String CDMF_SCOPE_SEPERATOR = "/";
private static String CDMF_HTTP_CONTENT_VALIDATOR = "iot-http";
public static final String DEVICE_ID_JSON_PATH = "event.metaData.deviceId";
@Override
public String getType() {
return CDMF_HTTP_CONTENT_VALIDATOR;
}
@Override
public ContentInfo validate(Object msgPayload, Map<String, Object> dynamicParams) {
String deviceId = (String) dynamicParams.get("deviceId");
String msg = (String) msgPayload;
String deviceIdJsonPath = DEVICE_ID_JSON_PATH;
boolean status;
if (msg.startsWith(JSON_ARRAY_START_CHAR)) {
status = processMultipleEvents(msg, deviceId, deviceIdJsonPath);
} else {
status = processSingleEvent(msg, deviceId, deviceIdJsonPath);
}
return new ContentInfo(status, msg);
}
private boolean processSingleEvent(String msg, String deviceIdFromTopic, String deviceIdJsonPath) {
Object res = JsonPath.read(msg, deviceIdJsonPath);
String deviceIdFromContent = (res != null) ? res.toString() : "";
if (deviceIdFromContent.equals(deviceIdFromTopic)) {
return true;
}
return false;
}
private boolean processMultipleEvents(String msg, String deviceIdFromTopic, String deviceIdJsonPath) {
try {
JSONParser jsonParser = new JSONParser();
JSONArray jsonArray = (JSONArray) jsonParser.parse(msg);
boolean status = false;
for (int i = 0; i < jsonArray.size(); i++) {
status = processSingleEvent(jsonArray.get(i).toString(), deviceIdFromTopic, deviceIdJsonPath);
if (!status) {
return status;
}
}
return status;
} catch (ParseException e) {
log.error("Invalid input " + msg, e);
return false;
}
}
}

@ -16,7 +16,7 @@
* under the License.
*/
package org.wso2.carbon.device.mgt.input.adapter.mqtt.util;
package org.wso2.carbon.device.mgt.input.adapter.extension.validator;
import com.jayway.jsonpath.JsonPath;
import org.apache.commons.logging.Log;
@ -32,13 +32,23 @@ import java.util.Map;
public class MQTTContentValidator implements ContentValidator {
private static final String JSON_ARRAY_START_CHAR = "[";
private static final Log log = LogFactory.getLog(MQTTContentValidator.class);
private static final String CDMF_MQTT_CONTENT_VALIDATOR = "iot-mqtt";
public static final String DEVICE_ID_JSON_PATH = "event.metaData.deviceId";
public static final String DEVICE_TYPE_JSON_PATH = "event.metaData.deviceId";
public static final String TOPIC = "topic";
public static final int DEVICE_ID_TOPIC_HIERARCHY_INDEX = 2;
@Override
public String getType() {
return null;
}
@Override
public ContentInfo validate(Object msgPayload, Map<String, Object> dynamicParams) {
String topic = (String) dynamicParams.get(MQTTEventAdapterConstants.TOPIC);
String topic = (String) dynamicParams.get(TOPIC);
String topics[] = topic.split("/");
String deviceIdJsonPath = MQTTEventAdapterConstants.DEVICE_ID_JSON_PATH;
int deviceIdInTopicHierarchyLevelIndex = MQTTEventAdapterConstants.DEVICE_ID_TOPIC_HIERARCHY_INDEX;
String deviceIdJsonPath = DEVICE_ID_JSON_PATH;
int deviceIdInTopicHierarchyLevelIndex = DEVICE_ID_TOPIC_HIERARCHY_INDEX;
String deviceIdFromTopic = topics[deviceIdInTopicHierarchyLevelIndex];
boolean status;
String message = (String) msgPayload;

@ -76,6 +76,22 @@
<groupId>commons-pool.wso2</groupId>
<artifactId>commons-pool</artifactId>
</dependency>
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-core</artifactId>
</dependency>
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-jaxrs</artifactId>
</dependency>
<dependency>
<groupId>io.github.openfeign</groupId>
<artifactId>feign-gson</artifactId>
</dependency>
<dependency>
<groupId>javax.ws.rs</groupId>
<artifactId>jsr311-api</artifactId>
</dependency>
</dependencies>
<build>
@ -117,7 +133,6 @@
org.wso2.carbon.event.input.adapter.core,
org.wso2.carbon.event.input.adapter.core.*,
javax.xml.namespace; version=0.0.0,
com.jayway.jsonpath.*,
com.nimbusds.jose,
com.nimbusds.jose.crypto,
com.nimbusds.jwt,
@ -130,9 +145,27 @@
org.wso2.carbon.user.core.service,
org.wso2.carbon.user.core.tenant,
org.apache.commons.pool,
org.apache.commons.pool.impl
org.apache.commons.pool.impl,
feign,
feign.auth,
feign.codec,
feign.gson,
org.wso2.carbon.device.mgt.input.adapter.extension,
org.apache.axiom.util.base64,
org.apache.axis2.*,
org.apache.commons.httpclient.*,
org.apache.commons.logging,
org.apache.log4j,
org.wso2.carbon.context,
org.wso2.carbon.core.util,
org.wso2.carbon.identity.oauth2.*,
org.wso2.carbon.utils,
org.wso2.carbon.utils.multitenancy
</Import-Package>
<DynamicImport-Package>*</DynamicImport-Package>
<Embed-Dependency>
jsr311-api,
feign-jaxrs
</Embed-Dependency>
</instructions>
</configuration>
</plugin>

@ -76,12 +76,12 @@ public class HTTPEventAdapterFactory extends InputEventAdapterFactory {
propertyList.add(exposedTransportsProperty);
//Content Validator details
Property contentValidator = new Property(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME);
Property contentValidator = new Property(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE);
contentValidator.setDisplayName(
resourceBundle.getString(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME));
resourceBundle.getString(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE));
contentValidator.setRequired(false);
contentValidator.setHint(
resourceBundle.getString(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME_HINT));
resourceBundle.getString(HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE_HINT));
contentValidator.setDefaultValue(HTTPEventAdapterConstants.DEFAULT);
propertyList.add(contentValidator);

@ -18,11 +18,13 @@ package org.wso2.carbon.device.mgt.input.adapter.http;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.DeviceAuthorizer;
import org.wso2.carbon.device.mgt.input.adapter.http.internal.InputAdapterServiceDataHolder;
import org.wso2.carbon.device.mgt.input.adapter.http.oauth.OAuthAuthenticator;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.transformer.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.validator.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.http.exception.HTTPContentInitializationException;
import org.wso2.carbon.device.mgt.input.adapter.http.jwt.JWTAuthenticator;
import org.wso2.carbon.device.mgt.input.adapter.http.util.AuthenticationInfo;
@ -58,6 +60,7 @@ public class HTTPMessageServlet extends HttpServlet {
private String exposedTransports;
private static JWTAuthenticator jwtAuthenticator;
private static OAuthAuthenticator oAuthAuthenticator;
private static DeviceAuthorizer deviceAuthorizer;
public HTTPMessageServlet(InputEventAdapterListener eventAdaptorListener, int tenantId,
InputEventAdapterConfiguration eventAdapterConfiguration,
@ -67,48 +70,29 @@ public class HTTPMessageServlet extends HttpServlet {
this.exposedTransports = eventAdapterConfiguration.getProperties().get(
HTTPEventAdapterConstants.EXPOSED_TRANSPORTS);
String className = eventAdapterConfiguration.getProperties().get(
HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME);
if (HTTPEventAdapterConstants.DEFAULT.equals(className)) {
contentValidator = new DefaultContentValidator();
String contentValidatorType = eventAdapterConfiguration.getProperties().get(
HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE);
if (contentValidatorType == null || HTTPEventAdapterConstants.DEFAULT.equals(contentValidatorType)) {
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getDefaultContentValidator();
} else {
try {
Class<? extends ContentValidator> contentValidatorClass = Class.forName(className)
.asSubclass(ContentValidator.class);
contentValidator = contentValidatorClass.newInstance();
} catch (ClassNotFoundException e) {
throw new HTTPContentInitializationException(
"Unable to find the class validator: " + className, e);
} catch (InstantiationException e) {
throw new HTTPContentInitializationException(
"Unable to create an instance of :" + className, e);
} catch (IllegalAccessException e) {
throw new HTTPContentInitializationException("Access of the instance in not allowed.", e);
}
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentValidator(contentValidatorType);
}
String contentTransformerClassName = eventAdapterConfiguration.getProperties().get(
HTTPEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME);
if (contentTransformerClassName != null && contentTransformerClassName.equals(HTTPEventAdapterConstants.DEFAULT)) {
contentTransformer = new DefaultContentTransformer();
} else if (contentTransformerClassName != null && !contentTransformerClassName.isEmpty()) {
try {
Class<? extends ContentTransformer> contentTransformerClass = Class.forName(contentTransformerClassName)
.asSubclass(ContentTransformer.class);
contentTransformer = contentTransformerClass.newInstance();
} catch (ClassNotFoundException e) {
throw new HTTPContentInitializationException(
"Unable to find the class transformer: " + contentTransformerClassName, e);
} catch (InstantiationException e) {
throw new HTTPContentInitializationException(
"Unable to create an instance of :" + contentTransformerClassName, e);
} catch (IllegalAccessException e) {
throw new HTTPContentInitializationException("Access of the instance in not allowed.", e);
}
if (contentTransformerClassName == null || contentTransformerClassName.equals(HTTPEventAdapterConstants.DEFAULT)) {
contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getDefaultContentTransformer();
} else {
contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentTransformer(contentValidatorType);
}
jwtAuthenticator = new JWTAuthenticator();
oAuthAuthenticator = new OAuthAuthenticator(globalProperties);
deviceAuthorizer = new DeviceAuthorizer(globalProperties);
}
@Override
@ -177,14 +161,24 @@ public class HTTPMessageServlet extends HttpServlet {
paramMap.put(HTTPEventAdapterConstants.USERNAME_TAG, authenticationInfo.getUsername());
paramMap.put(HTTPEventAdapterConstants.TENANT_DOMAIN_TAG, authenticationInfo.getTenantDomain());
paramMap.put(HTTPEventAdapterConstants.SCOPE_TAG, authenticationInfo.getScopes());
if (contentValidator != null && contentTransformer != null) {
data = (String) contentTransformer.transform(data, paramMap);
ContentInfo contentInfo = contentValidator.validate(data, paramMap);
if (contentInfo != null && contentInfo.isValidContent()) {
HTTPEventAdapter.executorService.submit(new HTTPRequestProcessor(eventAdaptorListener,
(String) contentInfo.getMessage(), tenantId));
}
}
String deviceId = (String) paramMap.get("deviceId");
String deviceType = (String) paramMap.get("deviceType");
if (deviceAuthorizer.isAuthorized(authenticationInfo, deviceId, deviceType)) {
if (contentValidator != null && contentTransformer != null) {
data = (String) contentTransformer.transform(data, paramMap);
ContentInfo contentInfo = contentValidator.validate(data, paramMap);
if (contentInfo != null && contentInfo.isValidContent()) {
HTTPEventAdapter.executorService.submit(new HTTPRequestProcessor(eventAdaptorListener,
(String) contentInfo
.getMessage(),
tenantId));
}
}
} else {
if (log.isDebugEnabled()) {
log.debug("Unauthorized device with device id" + deviceId + " and device type" + deviceType);
}
}
}
}

@ -0,0 +1,101 @@
/*
* 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.input.adapter.http.authorization;
import feign.Feign;
import feign.FeignException;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;
import feign.jaxrs.JAXRSContract;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.OAuthRequestInterceptor;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.AuthorizationRequest;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.DeviceAccessAuthorizationAdminService;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.DeviceAuthorizationResult;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.DeviceIdentifier;
import org.wso2.carbon.device.mgt.input.adapter.http.util.AuthenticationInfo;
import org.wso2.carbon.device.mgt.input.adapter.http.util.PropertyUtils;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterException;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* This authorizer crossvalidates the request with device id and device type.
*/
public class DeviceAuthorizer {
private static DeviceAccessAuthorizationAdminService deviceAccessAuthorizationAdminService;
private static final String CDMF_SERVER_BASE_CONTEXT = "/api/device-mgt/v1.0";
private static final String DEVICE_MGT_SERVER_URL = "deviceMgtServerUrl";
private static Log logger = LogFactory.getLog(DeviceAuthorizer.class);
public DeviceAuthorizer(Map<String, String> globalProperties) {
try {
deviceAccessAuthorizationAdminService = Feign.builder()
.requestInterceptor(new OAuthRequestInterceptor(globalProperties))
.contract(new JAXRSContract()).encoder(new GsonEncoder()).decoder(new GsonDecoder())
.target(DeviceAccessAuthorizationAdminService.class, getDeviceMgtServerUrl(globalProperties)
+ CDMF_SERVER_BASE_CONTEXT);
} catch (InputEventAdapterException e) {
logger.error("Invalid value for deviceMgtServerUrl in globalProperties.");
}
}
public boolean isAuthorized(AuthenticationInfo authenticationInfo, String deviceId, String deviceType) {
if (deviceId != null && !deviceId.isEmpty() && deviceType != null && !deviceType.isEmpty()) {
AuthorizationRequest authorizationRequest = new AuthorizationRequest();
authorizationRequest.setTenantDomain(authenticationInfo.getTenantDomain());
authorizationRequest.setUsername(authenticationInfo.getUsername());
DeviceIdentifier deviceIdentifier = new DeviceIdentifier();
deviceIdentifier.setId(deviceId);
deviceIdentifier.setType(deviceType);
List<DeviceIdentifier> deviceIdentifiers = new ArrayList<>();
deviceIdentifiers.add(deviceIdentifier);
authorizationRequest.setDeviceIdentifiers(deviceIdentifiers);
try {
DeviceAuthorizationResult deviceAuthorizationResult =
deviceAccessAuthorizationAdminService.isAuthorized(authorizationRequest);
List<DeviceIdentifier> devices = deviceAuthorizationResult.getAuthorizedDevices();
if (devices != null && devices.size() > 0) {
DeviceIdentifier authorizedDevice = devices.get(0);
if (authorizedDevice.getId().equals(deviceId) && authorizedDevice.getType().equals(deviceType)) {
return true;
}
}
} catch (FeignException e) {
logger.error(e.getMessage(), e);
}
}
return false;
}
private String getDeviceMgtServerUrl(Map<String, String> properties) throws InputEventAdapterException {
String deviceMgtServerUrl = PropertyUtils.replaceProperty(properties.get(DEVICE_MGT_SERVER_URL));
if (deviceMgtServerUrl == null || deviceMgtServerUrl.isEmpty()) {
logger.error("deviceMgtServerUrl can't be empty ");
}
return deviceMgtServerUrl;
}
}

@ -0,0 +1,162 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client;
import feign.Feign;
import feign.RequestInterceptor;
import feign.RequestTemplate;
import feign.auth.BasicAuthRequestInterceptor;
import feign.gson.GsonDecoder;
import feign.gson.GsonEncoder;
import feign.jaxrs.JAXRSContract;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.AccessTokenInfo;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.ApiApplicationKey;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.ApiApplicationRegistrationService;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.ApiRegistrationProfile;
import org.wso2.carbon.device.mgt.input.adapter.http.authorization.client.dto.TokenIssuerService;
import org.wso2.carbon.device.mgt.input.adapter.http.util.PropertyUtils;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterException;
import java.util.Map;
/**
* This is a request interceptor to add oauth token header.
*/
public class OAuthRequestInterceptor implements RequestInterceptor {
private AccessTokenInfo tokenInfo;
private long refreshTimeOffset;
private static final String API_APPLICATION_REGISTRATION_CONTEXT = "/api-application-registration";
private static final String DEVICE_MANAGEMENT_SERVICE_TAG[] = {"device_management"};
private static final String APPLICATION_NAME = "websocket-app";
private static final String PASSWORD_GRANT_TYPE = "password";
private static final String REFRESH_GRANT_TYPE = "refresh_token";
private static final String REQUIRED_SCOPE = "perm:authorization:verify";
private ApiApplicationRegistrationService apiApplicationRegistrationService;
private TokenIssuerService tokenIssuerService;
private static Log logger = LogFactory.getLog(OAuthRequestInterceptor.class);
private static final String CONNECTION_USERNAME = "username";
private static final String CONNECTION_PASSWORD = "password";
private static final String TOKEN_ENDPOINT = "tokenUrl";
private static final String TOKEN_REFRESH_TIME_OFFSET = "tokenRefreshTimeOffset";
private static final String TOKEN_SCOPES = "scopes";
private static final String DEVICE_MGT_SERVER_URL = "deviceMgtServerUrl";
private static final String TOKEN_ENDPOINT_CONTEXT = "tokenUrl";
private static String username;
private static String password;
private static String tokenEndpoint;
private static String deviceMgtServerUrl;
private static String scopes;
private static Map<String, String> globalProperties;
/**
* Creates an interceptor that authenticates all requests.
*/
public OAuthRequestInterceptor(Map<String, String> globalProperties) {
this.globalProperties = globalProperties;
try {
deviceMgtServerUrl = getDeviceMgtServerUrl(globalProperties);
refreshTimeOffset = getRefreshTimeOffset(globalProperties) * 1000;
username = getUsername(globalProperties);
password = getPassword(globalProperties);
tokenEndpoint = getTokenEndpoint(globalProperties);
apiApplicationRegistrationService = Feign.builder().requestInterceptor(
new BasicAuthRequestInterceptor(username, password))
.contract(new JAXRSContract()).encoder(new GsonEncoder()).decoder(new GsonDecoder())
.target(ApiApplicationRegistrationService.class,
deviceMgtServerUrl + API_APPLICATION_REGISTRATION_CONTEXT);
} catch (InputEventAdapterException e) {
logger.error("Invalid url: deviceMgtServerUrl" + deviceMgtServerUrl + " or tokenEndpoint:" + tokenEndpoint,
e);
}
}
@Override
public void apply(RequestTemplate template) {
if (tokenInfo == null) {
//had to do on demand initialization due to start up error.
ApiRegistrationProfile apiRegistrationProfile = new ApiRegistrationProfile();
apiRegistrationProfile.setApplicationName(APPLICATION_NAME);
apiRegistrationProfile.setIsAllowedToAllDomains(false);
apiRegistrationProfile.setIsMappingAnExistingOAuthApp(false);
apiRegistrationProfile.setTags(DEVICE_MANAGEMENT_SERVICE_TAG);
ApiApplicationKey apiApplicationKey = apiApplicationRegistrationService.register(apiRegistrationProfile);
String consumerKey = apiApplicationKey.getConsumerKey();
String consumerSecret = apiApplicationKey.getConsumerSecret();
tokenIssuerService = Feign.builder().requestInterceptor(
new BasicAuthRequestInterceptor(consumerKey, consumerSecret))
.contract(new JAXRSContract()).encoder(new GsonEncoder()).decoder(new GsonDecoder())
.target(TokenIssuerService.class, tokenEndpoint);
tokenInfo = tokenIssuerService.getToken(PASSWORD_GRANT_TYPE, username, password, REQUIRED_SCOPE);
tokenInfo.setExpires_in(System.currentTimeMillis() + (tokenInfo.getExpires_in() * 1000));
}
synchronized(this) {
if (System.currentTimeMillis() + refreshTimeOffset > tokenInfo.getExpires_in()) {
tokenInfo = tokenIssuerService.getToken(REFRESH_GRANT_TYPE, tokenInfo.getRefresh_token());
tokenInfo.setExpires_in(System.currentTimeMillis() + tokenInfo.getExpires_in());
}
}
String headerValue = "Bearer " + tokenInfo.getAccess_token();
template.header("Authorization", headerValue);
}
private String getUsername(Map<String, String> globalProperties) {
String username = globalProperties.get(CONNECTION_USERNAME);
if (username == null || username.isEmpty()) {
logger.error("username can't be empty ");
}
return username;
}
private String getPassword(Map<String, String> globalProperties) {
String password = globalProperties.get(CONNECTION_PASSWORD);;
if (password == null || password.isEmpty()) {
logger.error("password can't be empty ");
}
return password;
}
private String getDeviceMgtServerUrl(Map<String, String> globalProperties) throws InputEventAdapterException {
String deviceMgtServerUrl = globalProperties.get(DEVICE_MGT_SERVER_URL);
if (deviceMgtServerUrl == null || deviceMgtServerUrl.isEmpty()) {
logger.error("deviceMgtServerUrl can't be empty ");
}
return PropertyUtils.replaceProperty(deviceMgtServerUrl);
}
private String getTokenEndpoint(Map<String, String> globalProperties) throws InputEventAdapterException {
String tokenEndpoint = globalProperties.get(TOKEN_ENDPOINT_CONTEXT);
if ( tokenEndpoint.isEmpty()) {
logger.error("tokenEndpoint can't be empty ");
}
return PropertyUtils.replaceProperty(tokenEndpoint);
}
private long getRefreshTimeOffset(Map<String, String> globalProperties) {
long refreshTimeOffset = 100;
try {
refreshTimeOffset = Long.parseLong(globalProperties.get(TOKEN_REFRESH_TIME_OFFSET));
} catch (NumberFormatException e) {
logger.error("refreshTimeOffset should be a number", e);
}
return refreshTimeOffset;
}
}

@ -0,0 +1,57 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
/**
* This hold access token info that returned from the api call
*/
public class AccessTokenInfo {
public String token_type;
public long expires_in;
public String refresh_token;
public String access_token;
public String getToken_type() {
return token_type;
}
public void setToken_type(String token_type) {
this.token_type = token_type;
}
public long getExpires_in() {
return expires_in;
}
public void setExpires_in(long expires_in) {
this.expires_in = expires_in;
}
public String getRefresh_token() {
return refresh_token;
}
public void setRefresh_token(String refresh_token) {
this.refresh_token = refresh_token;
}
public String getAccess_token() {
return access_token;
}
public void setAccess_token(String access_token) {
this.access_token = access_token;
}
}

@ -0,0 +1,43 @@
/*
* 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.input.adapter.http.authorization.client.dto;
/**
* This holds api application consumer key and secret.
*/
public class ApiApplicationKey {
private String client_id;
private String client_secret;
public String getConsumerKey() {
return this.client_id;
}
public void setClient_id(String consumerKey) {
this.client_id = consumerKey;
}
public String getConsumerSecret() {
return this.client_secret;
}
public void setClient_secret(String consumerSecret) {
this.client_secret = consumerSecret;
}
}

@ -0,0 +1,38 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
/**
* This is the application registration service that exposed for apimApplicationRegistration
*/
@Path("/register")
public interface ApiApplicationRegistrationService {
/**
* This method is used to register api application
*
* @param registrationProfile contains the necessary attributes that are needed in order to register an app.
*/
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
ApiApplicationKey register(ApiRegistrationProfile registrationProfile);
}

@ -0,0 +1,78 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
/**
* This class represents the data that are required to register
* the oauth application.
*/
public class ApiRegistrationProfile {
public String applicationName;
public String tags[];
public boolean isAllowedToAllDomains;
public String consumerKey;
public String consumerSecret;
public boolean isMappingAnExistingOAuthApp;
public String getApplicationName() {
return applicationName;
}
public void setApplicationName(String applicationName) {
this.applicationName = applicationName;
}
public String[] getTags() {
return tags;
}
public void setTags(String[] tags) {
this.tags = tags;
}
public boolean isAllowedToAllDomains() {
return isAllowedToAllDomains;
}
public void setIsAllowedToAllDomains(boolean isAllowedToAllDomains) {
this.isAllowedToAllDomains = isAllowedToAllDomains;
}
public boolean isMappingAnExistingOAuthApp() {
return isMappingAnExistingOAuthApp;
}
public void setIsMappingAnExistingOAuthApp(boolean isMappingAnExistingOAuthApp) {
this.isMappingAnExistingOAuthApp = isMappingAnExistingOAuthApp;
}
public String getConsumerKey() {
return consumerKey;
}
public void setConsumerKey(String consumerKey) {
this.consumerKey = consumerKey;
}
public String getConsumerSecret() {
return consumerSecret;
}
public void setConsumerSecret(String consumerSecret) {
this.consumerSecret = consumerSecret;
}
}

@ -0,0 +1,59 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
import java.util.List;
/**
* DTO of the authorization request
*/
public class AuthorizationRequest {
String tenantDomain;
String username;
List<DeviceIdentifier> deviceIdentifiers;
List<String> permissions;
public String getTenantDomain() {
return tenantDomain;
}
public void setTenantDomain(String tenantDomain) {
this.tenantDomain = tenantDomain;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public List<DeviceIdentifier> getDeviceIdentifiers() {
return deviceIdentifiers;
}
public void setDeviceIdentifiers(List<DeviceIdentifier> deviceIdentifiers) {
this.deviceIdentifiers = deviceIdentifiers;
}
public List<String> getPermissions() {
return permissions;
}
public void setPermissions(List<String> permissions) {
this.permissions = permissions;
}
}

@ -0,0 +1,41 @@
/*
* 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.input.adapter.http.authorization.client.dto;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Path;
import javax.ws.rs.Produces;
import javax.ws.rs.core.MediaType;
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
@Path("/admin/authorization")
/**
* This interface provided the definition of the device - user access verification service.
*/
public interface DeviceAccessAuthorizationAdminService {
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_JSON)
DeviceAuthorizationResult isAuthorized(AuthorizationRequest authorizationRequest);
}

@ -0,0 +1,56 @@
/*
* 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.device.mgt.input.adapter.http.authorization.client.dto;
import java.util.ArrayList;
import java.util.List;
/**
* Represents a DeviceAuthorizationResult including a list of authorized devices and a list of unauthorized devices.
*/
public class DeviceAuthorizationResult {
private List<DeviceIdentifier> authorizedDevices = new ArrayList<>();
private List<DeviceIdentifier> unauthorizedDevices = new ArrayList<>();
public List<DeviceIdentifier> getAuthorizedDevices() {
return authorizedDevices;
}
public void setAuthorizedDevices(List<DeviceIdentifier> authorizedDevices) {
this.authorizedDevices = authorizedDevices;
}
public void setUnauthorizedDevices(
List<DeviceIdentifier> unauthorizedDevices) {
this.unauthorizedDevices = unauthorizedDevices;
}
public void addAuthorizedDevice(DeviceIdentifier deviceIdentifier) {
authorizedDevices.add(deviceIdentifier);
}
public List<DeviceIdentifier> getUnauthorizedDevices() {
return unauthorizedDevices;
}
public void addUnauthorizedDevice(DeviceIdentifier deviceIdentifier) {
unauthorizedDevices.add(deviceIdentifier);
}
}

@ -0,0 +1,51 @@
/*
* Copyright (c) 2014, 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.input.adapter.http.authorization.client.dto;
import java.io.Serializable;
/**
* DTO of the device identifier
*/
public class DeviceIdentifier implements Serializable{
private String id;
private String type;
public DeviceIdentifier() {}
public DeviceIdentifier(String id, String type) {
this.id = id;
this.type = type;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type.toLowerCase();
}
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
}

@ -0,0 +1,58 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
/**
* This class represents an OAuth application populated with necessary data.
*/
public class OAuthApplicationInfo {
public String client_id;
public String client_name;
public String callback_url;
public String client_secret;
public String getClient_id() {
return client_id;
}
public void setClient_id(String client_id) {
this.client_id = client_id;
}
public String getClient_name() {
return client_name;
}
public void setClient_name(String client_name) {
this.client_name = client_name;
}
public String getCallback_url() {
return callback_url;
}
public void setCallback_url(String callback_url) {
this.callback_url = callback_url;
}
public String getClient_secret() {
return client_secret;
}
public void setClient_secret(String client_secret) {
this.client_secret = client_secret;
}
}

@ -0,0 +1,40 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
/**
* This holds the data related to registration.
*/
public class RegisterInfo {
private boolean isRegistered;
private String msg;
public boolean isRegistered() {
return isRegistered;
}
public void setIsRegistered(boolean isRegistered) {
this.isRegistered = isRegistered;
}
public String getMsg() {
return msg;
}
public void setMsg(String msg) {
this.msg = msg;
}
}

@ -0,0 +1,78 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
/**
* This class represents the data that are required to register
* the oauth application.
*/
public class RegistrationProfile {
public String callbackUrl;
public String clientName;
public String tokenScope;
public String owner;
public String grantType;
public String applicationType;
public String getCallbackUrl() {
return callbackUrl;
}
public void setCallbackUrl(String callBackUrl) {
this.callbackUrl = callBackUrl;
}
public String getClientName() {
return clientName;
}
public void setClientName(String clientName) {
this.clientName = clientName;
}
public String getTokenScope() {
return tokenScope;
}
public void setTokenScope(String tokenScope) {
this.tokenScope = tokenScope;
}
public String getOwner() {
return owner;
}
public void setOwner(String owner) {
this.owner = owner;
}
public String getGrantType() {
return grantType;
}
public void setGrantType(String grantType) {
this.grantType = grantType;
}
public String getApplicationType() {
return applicationType;
}
public void setApplicationType(String applicationType) {
this.applicationType = applicationType;
}
}

@ -0,0 +1,56 @@
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.
*
*/
/*
* Copyright (c) 2016, WSO2 Inc. (http://www.wso2.org) All Rights Reserved.
*
* Licensed 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.input.adapter.http.authorization.client.dto;
import javax.ws.rs.Consumes;
import javax.ws.rs.POST;
import javax.ws.rs.Produces;
import javax.ws.rs.QueryParam;
import javax.ws.rs.core.MediaType;
/**
* This hold the api defintion that is used as a contract with netflix feign.
*/
public interface TokenIssuerService {
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
AccessTokenInfo getToken(@QueryParam("grant_type") String grant, @QueryParam("username") String username,
@QueryParam("password") String password);
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
AccessTokenInfo getToken(@QueryParam("grant_type") String grant, @QueryParam("username") String username,
@QueryParam("password") String password, @QueryParam("scope") String scopes);
@POST
@Produces(MediaType.APPLICATION_JSON)
@Consumes(MediaType.APPLICATION_FORM_URLENCODED)
AccessTokenInfo getToken(@QueryParam("grant_type") String grant, @QueryParam("refresh_token") String refreshToken);
}

@ -21,6 +21,7 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.device.mgt.input.adapter.http.HTTPEventAdapterFactory;
import org.wso2.carbon.event.input.adapter.core.InputEventAdapterFactory;
import org.wso2.carbon.user.core.service.RealmService;
@ -29,9 +30,19 @@ import org.wso2.carbon.user.core.service.RealmService;
* @scr.component name="input.iot.http.AdapterService.component" immediate="true"
* @scr.reference name="user.realmservice.default"
* interface="org.wso2.carbon.user.core.service.RealmService" cardinality="1..1"
* policy="dynamic" bind="setRealmService" unbind="unsetRealmService"
* policy="dynamic"
* bind="setRealmService"
* unbind="unsetRealmService"
* @scr.reference name="http.service" interface="org.osgi.service.http.HttpService"
* cardinality="1..1" policy="dynamic" bind="setHttpService" unbind="unsetHttpService"
* cardinality="1..1"
* policy="dynamic"
* bind="setHttpService"
* unbind="unsetHttpService"
* @scr.reference name="input.extension.service" interface="org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService"
* cardinality="1..1"
* policy="dynamic"
* bind="setInputAdapterExtensionService"
* unbind="unsetInputAdapterExtensionService"
*/
public class InputAdapterServiceComponent {
@ -67,4 +78,12 @@ public class InputAdapterServiceComponent {
InputAdapterServiceDataHolder.registerHTTPService(null);
}
protected void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(inputAdapterExtensionService);
}
protected void unsetInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(null);
}
}

@ -15,6 +15,7 @@
package org.wso2.carbon.device.mgt.input.adapter.http.internal;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.user.core.service.RealmService;
/**
@ -24,6 +25,7 @@ public final class InputAdapterServiceDataHolder {
private static RealmService realmService;
private static HttpService httpService;
private static InputAdapterExtensionService inputAdapterExtensionService;
private InputAdapterServiceDataHolder() {
}
@ -46,5 +48,12 @@ public final class InputAdapterServiceDataHolder {
return httpService;
}
public static void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.inputAdapterExtensionService = inputAdapterExtensionService;
}
public static InputAdapterExtensionService getInputAdapterExtensionService() {
return inputAdapterExtensionService;
}
}

@ -1,99 +0,0 @@
/*
* 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.input.adapter.http.util;
import com.jayway.jsonpath.JsonPath;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.json.simple.JSONArray;
import org.json.simple.parser.JSONParser;
import org.json.simple.parser.ParseException;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import java.util.List;
import java.util.Map;
public class HTTPContentValidator implements ContentValidator {
private static final Log log = LogFactory.getLog(HTTPContentValidator.class);
private static String JSON_ARRAY_START_CHAR = "[";
private static String CDMF_SCOPE_PREFIX = "cdmf";
private static String CDMF_SCOPE_SEPERATOR = "/";
@Override
public ContentInfo validate(Object msgPayload, Map<String, Object> dynamicParams) {
String deviceId = (String) dynamicParams.get("deviceId");
String deviceType = (String) dynamicParams.get("deviceType");
String msg = (String) msgPayload;
String deviceIdJsonPath = HTTPEventAdapterConstants.DEVICE_ID_JSON_PATH;
boolean status;
if (status = isValidDevice(deviceId, deviceType, dynamicParams)) {
if (msg.startsWith(JSON_ARRAY_START_CHAR)) {
status = processMultipleEvents(msg, deviceId, deviceIdJsonPath);
} else {
status = processSingleEvent(msg, deviceId, deviceIdJsonPath);
}
}
return new ContentInfo(status, msg);
}
private boolean processSingleEvent(String msg, String deviceIdFromTopic, String deviceIdJsonPath) {
Object res = JsonPath.read(msg, deviceIdJsonPath);
String deviceIdFromContent = (res != null) ? res.toString() : "";
if (deviceIdFromContent.equals(deviceIdFromTopic)) {
return true;
}
return false;
}
private boolean processMultipleEvents(String msg, String deviceIdFromTopic, String deviceIdJsonPath) {
try {
JSONParser jsonParser = new JSONParser();
JSONArray jsonArray = (JSONArray) jsonParser.parse(msg);
boolean status = false;
for (int i = 0; i < jsonArray.size(); i++) {
status = processSingleEvent(jsonArray.get(i).toString(), deviceIdFromTopic, deviceIdJsonPath);
if (!status) {
return status;
}
}
return status;
} catch (ParseException e) {
log.error("Invalid input " + msg, e);
return false;
}
}
private boolean isValidDevice(String deviceId, String deviceType, Map<String, Object> dynamicParams) {
List<String> scopes = (List<String>) dynamicParams.get(HTTPEventAdapterConstants.SCOPE_TAG);
if (scopes != null) {
for (String scope : scopes) {
if (scope.startsWith(CDMF_SCOPE_PREFIX)) {
String deviceIdInfo[] = scope.split(CDMF_SCOPE_SEPERATOR);
if (deviceIdInfo.length == 3) {
if (deviceId.equals(deviceIdInfo[2]) && deviceType.equals(deviceIdInfo[1])) {
return true;
}
}
}
}
}
return false;
}
}

@ -48,27 +48,17 @@ public final class HTTPEventAdapterConstants {
public static final int DEFAULT_HTTP_PORT = 9763;
public static final int DEFAULT_HTTPS_PORT = 9443;
public static final String MAXIMUM_TOTAL_HTTP_CONNECTION = "maximumTotalHttpConnection";
public static final String MAXIMUM_TOTAL_HTTP_CONNECTION_HINT = "maximumTotalHttpConnection.hint";
public static final String MAXIMUM_HTTP_CONNECTION_PER_HOST = "maximumHttpConnectionPerHost";
public static final String MAXIMUM_HTTP_CONNECTION_PER_HOST_HINT = "maximumHttpConnectionPerHost.hint";
public static final String TOKEN_VALIDATION_ENDPOINT_URL = "keymanagerUrl";
public static final String TOKEN_VALIDATION_ENDPOINT_URL = "tokenUrl";
public static final String TOKEN_VALIDATION_POST_FIX = "/services/OAuth2TokenValidationService";
public static final String USERNAME = "username";
public static final String USERNAME_HINT = "username.hint";
public static final String PASSWORD = "password";
public static final String PASSWORD_HINT = "password.hint";
public static final String DEFAULT_STRING = "default";
public static final String MAX_HTTP_CONNECTION = "2";
public static final String MAX_TOTAL_HTTP_CONNECTION = "100";
public static final String TENANT_DOMAIN_TAG = "tenantDomain";
public static final String USERNAME_TAG = "username";
public static final String SCOPE_TAG = "scopes";
public static final String PAYLOAD_TAG = "payload";
public static final String DEVICE_ID_JSON_PATH = "event.metaData.deviceId";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME = "contentValidator";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME_HINT = "contentValidator.hint";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_TYPE = "contentValidator";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_TYPE_HINT = "contentValidator.hint";
public static final String DEFAULT = "default";
public static final String HTTP_CONTENT_VALIDATION_DEFAULT_PARAMETERS = "";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME = "contentTransformer";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME_HINT = "contentTransformer.hint";
}

@ -0,0 +1,45 @@
/*
* 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.input.adapter.http.util;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class PropertyUtils {
//This method is only used if the mb features are within DAS.
public static String replaceProperty(String urlWithPlaceholders) throws InputEventAdapterException {
String regex = "\\$\\{(.*?)\\}";
Pattern pattern = Pattern.compile(regex);
Matcher matchPattern = pattern.matcher(urlWithPlaceholders);
while (matchPattern.find()) {
String sysPropertyName = matchPattern.group(1);
String sysPropertyValue = System.getProperty(sysPropertyName);
if (sysPropertyValue != null && !sysPropertyName.isEmpty()) {
urlWithPlaceholders = urlWithPlaceholders.replaceAll("\\$\\{(" + sysPropertyName + ")\\}", sysPropertyValue);
} else {
throw new InputEventAdapterException("System property - " + sysPropertyName
+ " is not defined, hence cannot resolve : " + urlWithPlaceholders);
}
}
return urlWithPlaceholders;
}
}

@ -23,6 +23,6 @@ http.usage.tips_mid2=/endpoints/&lt;event_receiver_name&gt;</i></br></br>For oth
http.usage.tips_mid3=/endpoints/t/&lt;tenant_domain&gt;/&lt;event_receiver_name&gt;</i></br>&nbsp;&nbsp;<i>https://localhost:
http.usage.tips_postfix=/endpoints/t/&lt;tenant_domain&gt;/&lt;event_receiver_name&gt;</i>
contentValidator=contentValidator
contentValidator.hint=Class Name of the content Validation or 'default' to set default class, required to implement (if required)
contentValidator.hint=Type of the content Validation or 'default' to set default impl, required to implement (if required)
contentTransformer=contentTransformer
contentTransformer.hint=Class Name of the content transformer or 'default' to set default class, required to implement (if required)
contentTransformer.hint=Type of the content transformer or 'default' to set default type, required to implement (if required)

@ -72,6 +72,10 @@
<groupId>org.wso2.carbon.devicemgt-plugins</groupId>
<artifactId>org.wso2.carbon.device.mgt.input.adapter.extension</artifactId>
</dependency>
<dependency>
<groupId>org.wso2.carbon.devicemgt</groupId>
<artifactId>org.wso2.carbon.identity.jwt.client.extension</artifactId>
</dependency>
</dependencies>
<build>
@ -124,9 +128,20 @@
org.apache.http.client.methods;version="${httpclient.version.range}",
org.apache.http.impl.client;version="${httpclient.version.range}",
org.json.simple.*,
com.jayway.jsonpath.*
com.jayway.jsonpath.*,
org.wso2.carbon.identity.jwt.client.extension.*,
javax.net.ssl,
org.apache.commons.codec.binary,
org.apache.commons.logging,
org.apache.http.entity,
org.osgi.framework,
org.osgi.service.component,
org.osgi.service.http,
org.wso2.carbon.context,
org.wso2.carbon.core,
org.wso2.carbon.device.mgt.input.adapter.extension,
org.wso2.carbon.user.api
</Import-Package>
<DynamicImport-Package>*</DynamicImport-Package>
</instructions>
</configuration>
</plugin>

@ -53,7 +53,6 @@ public class MQTTEventAdapter implements InputEventAdapter {
public void init(InputEventAdapterListener eventAdapterListener) throws InputEventAdapterException {
this.eventAdapterListener = eventAdapterListener;
try {
mqttBrokerConnectionConfiguration = new MQTTBrokerConnectionConfiguration(eventAdapterConfiguration
,globalProperties);
mqttAdapterListener = new MQTTAdapterListener(mqttBrokerConnectionConfiguration

@ -65,12 +65,12 @@ public class MQTTEventAdapterFactory extends InputEventAdapterFactory {
//Content Validator details
Property contentValidator = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME);
Property contentValidator = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE);
contentValidator.setDisplayName(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME));
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE));
contentValidator.setRequired(false);
contentValidator.setHint(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME_HINT));
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE_HINT));
contentValidator.setDefaultValue(MQTTEventAdapterConstants.DEFAULT);
propertyList.add(contentValidator);
@ -78,7 +78,7 @@ public class MQTTEventAdapterFactory extends InputEventAdapterFactory {
Property userName = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_USERNAME);
userName.setDisplayName(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_USERNAME));
userName.setRequired(true);
userName.setRequired(false);
userName.setHint(resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_USERNAME_HINT));
propertyList.add(userName);
@ -86,7 +86,7 @@ public class MQTTEventAdapterFactory extends InputEventAdapterFactory {
Property password = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_PASSWORD);
userName.setDisplayName(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_PASSWORD));
userName.setRequired(true);
userName.setRequired(false);
userName.setHint(resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_PASSWORD_HINT));
propertyList.add(password);
@ -108,12 +108,12 @@ public class MQTTEventAdapterFactory extends InputEventAdapterFactory {
propertyList.add(clearSession);
//Content Transformer details
Property contentTransformer = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME);
Property contentTransformer = new Property(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE);
contentTransformer.setDisplayName(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME));
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE));
contentTransformer.setRequired(false);
contentTransformer.setHint(
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME_HINT));
resourceBundle.getString(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE_HINT));
contentTransformer.setDefaultValue(MQTTEventAdapterConstants.DEFAULT);
propertyList.add(contentTransformer);

@ -21,11 +21,23 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.device.mgt.input.adapter.mqtt.MQTTEventAdapterFactory;
import org.wso2.carbon.event.input.adapter.core.InputEventAdapterFactory;
import org.wso2.carbon.identity.jwt.client.extension.service.JWTClientManagerService;
/**
* @scr.component name="input.iot.mqtt.AdapterService.component" immediate="true"
* @scr.reference name="input.extension.service" interface="org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService"
* cardinality="1..1"
* policy="dynamic"
* bind="setInputAdapterExtensionService"
* unbind="unsetInputAdapterExtensionService"
* @scr.reference name="jwt.client.service" interface="org.wso2.carbon.identity.jwt.client.extension.service.JWTClientManagerService"
* cardinality="1..1"
* policy="dynamic"
* bind="setJWTClientManagerService"
* unbind="unsetJWTClientManagerService"
*/
public class InputAdapterServiceComponent {
@ -52,4 +64,20 @@ public class InputAdapterServiceComponent {
InputAdapterServiceDataHolder.registerHTTPService(null);
}
protected void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(inputAdapterExtensionService);
}
protected void unsetInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(null);
}
protected void setJWTClientManagerService(JWTClientManagerService jwtClientManagerService) {
InputAdapterServiceDataHolder.setJwtClientManagerService(jwtClientManagerService);
}
protected void unsetJWTClientManagerService(JWTClientManagerService jwtClientManagerService) {
InputAdapterServiceDataHolder.setJwtClientManagerService(null);
}
}

@ -15,6 +15,8 @@
package org.wso2.carbon.device.mgt.input.adapter.mqtt.internal;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.identity.jwt.client.extension.service.JWTClientManagerService;
/**
* common place to hold some OSGI service references.
@ -22,6 +24,8 @@ import org.osgi.service.http.HttpService;
public final class InputAdapterServiceDataHolder {
private static HttpService httpService;
private static InputAdapterExtensionService inputAdapterExtensionService;
private static JWTClientManagerService jwtClientManagerService;
private InputAdapterServiceDataHolder() {
}
@ -35,5 +39,20 @@ public final class InputAdapterServiceDataHolder {
return httpService;
}
public static void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.inputAdapterExtensionService = inputAdapterExtensionService;
}
public static InputAdapterExtensionService getInputAdapterExtensionService() {
return inputAdapterExtensionService;
}
public static JWTClientManagerService getJwtClientManagerService() {
return jwtClientManagerService;
}
public static void setJwtClientManagerService(
JWTClientManagerService jwtClientManagerService) {
InputAdapterServiceDataHolder.jwtClientManagerService = jwtClientManagerService;
}
}

@ -21,14 +21,11 @@ import org.apache.commons.codec.binary.Base64;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.ContentType;
import org.apache.http.entity.StringEntity;
import org.apache.http.message.BasicHeader;
import org.apache.http.message.BasicNameValuePair;
import org.eclipse.paho.client.mqttv3.*;
import org.eclipse.paho.client.mqttv3.persist.MqttDefaultFilePersistence;
import org.json.simple.JSONObject;
@ -39,11 +36,13 @@ import org.wso2.carbon.core.ServerStatus;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.mqtt.internal.InputAdapterServiceDataHolder;
import org.wso2.carbon.event.input.adapter.core.InputEventAdapterListener;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterRuntimeException;
import org.wso2.carbon.device.mgt.input.adapter.mqtt.exception.MQTTContentInitializationException;
import org.wso2.carbon.identity.jwt.client.extension.dto.AccessTokenInfo;
import org.wso2.carbon.identity.jwt.client.extension.exception.JWTClientException;
import org.wso2.carbon.identity.jwt.client.extension.service.JWTClientManagerService;
import org.wso2.carbon.user.api.UserStoreException;
import java.io.IOException;
import java.net.MalformedURLException;
@ -51,9 +50,7 @@ import java.net.URL;
import java.security.KeyManagementException;
import java.security.KeyStoreException;
import java.security.NoSuchAlgorithmException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class MQTTAdapterListener implements MqttCallback, Runnable {
@ -83,7 +80,7 @@ public class MQTTAdapterListener implements MqttCallback, Runnable {
this.mqttBrokerConnectionConfiguration = mqttBrokerConnectionConfiguration;
this.cleanSession = mqttBrokerConnectionConfiguration.isCleanSession();
int keepAlive = mqttBrokerConnectionConfiguration.getKeepAlive();
this.topic = topic;
this.topic = PropertyUtils.replaceTenantDomainProperty(topic);
this.eventAdapterListener = inputEventAdapterListener;
this.tenantId = tenantId;
@ -102,43 +99,23 @@ public class MQTTAdapterListener implements MqttCallback, Runnable {
// Set this wrapper as the callback handler
mqttClient.setCallback(this);
String contentValidatorClassName = this.mqttBrokerConnectionConfiguration.getContentValidatorClassName();
String contentValidatorType = this.mqttBrokerConnectionConfiguration.getContentValidatorType();
if (contentValidatorClassName != null && contentValidatorClassName.equals(MQTTEventAdapterConstants.DEFAULT)) {
contentValidator = new DefaultContentValidator();
} else if (contentValidatorClassName != null && !contentValidatorClassName.isEmpty()) {
try {
Class<? extends ContentValidator> contentValidatorClass = Class.forName(contentValidatorClassName)
.asSubclass(ContentValidator.class);
contentValidator = contentValidatorClass.newInstance();
} catch (ClassNotFoundException e) {
throw new MQTTContentInitializationException(
"Unable to find the class validator: " + contentValidatorClassName, e);
} catch (InstantiationException e) {
throw new MQTTContentInitializationException(
"Unable to create an instance of :" + contentValidatorClassName, e);
} catch (IllegalAccessException e) {
throw new MQTTContentInitializationException("Access of the instance in not allowed.", e);
}
if (contentValidatorType == null || contentValidatorType.equals(MQTTEventAdapterConstants.DEFAULT)) {
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getDefaultContentValidator();
} else {
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentValidator(contentValidatorType);
}
String contentTransformerClassName = this.mqttBrokerConnectionConfiguration.getContentTransformerClassName();
if (contentTransformerClassName != null && contentTransformerClassName.equals(MQTTEventAdapterConstants.DEFAULT)) {
contentTransformer = new DefaultContentTransformer();
} else if (contentTransformerClassName != null && !contentTransformerClassName.isEmpty()) {
try {
Class<? extends ContentTransformer> contentTransformerClass = Class.forName(contentTransformerClassName)
.asSubclass(ContentTransformer.class);
contentTransformer = contentTransformerClass.newInstance();
} catch (ClassNotFoundException e) {
throw new MQTTContentInitializationException(
"Unable to find the class transfoer: " + contentTransformerClassName, e);
} catch (InstantiationException e) {
throw new MQTTContentInitializationException(
"Unable to create an instance of :" + contentTransformerClassName, e);
} catch (IllegalAccessException e) {
throw new MQTTContentInitializationException("Access of the instance in not allowed.", e);
}
String contentTransformerType = this.mqttBrokerConnectionConfiguration.getContentTransformerType();
if (contentTransformerType == null || contentTransformerType.equals(MQTTEventAdapterConstants.DEFAULT)) {
contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getDefaultContentTransformer();
} else {
contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentTransformer(contentTransformerType);
}
} catch (MqttException e) {
log.error("Exception occurred while subscribing to MQTT broker at "
@ -192,8 +169,10 @@ public class MQTTAdapterListener implements MqttCallback, Runnable {
}
} catch (MalformedURLException e) {
log.error("Invalid dcrUrl : " + dcrUrlString);
} catch (KeyManagementException | NoSuchAlgorithmException | KeyStoreException | IOException e) {
log.error("Failed to create an https connection.", e);
} catch (JWTClientException | UserStoreException e) {
log.error("Failed to create an oauth token with jwt grant type.", e);
} catch (NoSuchAlgorithmException |KeyManagementException |KeyStoreException | IOException e) {
log.error("Failed to create a http connection.", e);
}
}
}
@ -287,34 +266,19 @@ public class MQTTAdapterListener implements MqttCallback, Runnable {
}
private String getToken(String clientId, String clientSecret)
throws IOException, NoSuchAlgorithmException, KeyStoreException, KeyManagementException, ParseException {
URL tokenEndpoint = new URL(mqttBrokerConnectionConfiguration.getTokenUrl());
HttpClient httpClient = MQTTUtil.getHttpClient(tokenEndpoint.getProtocol());
HttpPost postMethod = new HttpPost(tokenEndpoint.toString());
List<NameValuePair> nameValuePairs = new ArrayList<>();
nameValuePairs.add(new BasicNameValuePair(MQTTEventAdapterConstants.GRANT_TYPE_PARAM_NAME,
MQTTEventAdapterConstants.PASSWORD_GRANT_TYPE));
nameValuePairs.add(new BasicNameValuePair(MQTTEventAdapterConstants.PASSWORD_GRANT_TYPE_USERNAME,
mqttBrokerConnectionConfiguration.getUsername()));
nameValuePairs.add(new BasicNameValuePair(MQTTEventAdapterConstants.PASSWORD_GRANT_TYPE_PASSWORD,
mqttBrokerConnectionConfiguration.getPassword()));
throws UserStoreException, JWTClientException {
String scopes = mqttBrokerConnectionConfiguration.getBrokerScopes();
if (scopes != null && !scopes.isEmpty()) {
nameValuePairs.add(new BasicNameValuePair(MQTTEventAdapterConstants.PASSWORD_GRANT_TYPE_SCOPES, scopes));
String username = mqttBrokerConnectionConfiguration.getUsername();
if (mqttBrokerConnectionConfiguration.isGlobalCredentailSet()) {
username = PrivilegedCarbonContext.getThreadLocalCarbonContext()
.getUserRealm().getRealmConfiguration().getAdminUserName() + "@" + PrivilegedCarbonContext
.getThreadLocalCarbonContext().getTenantDomain(true);
}
postMethod.setEntity(new UrlEncodedFormEntity(nameValuePairs));
postMethod.addHeader("Authorization", "Basic " + getBase64Encode(clientId, clientSecret));
postMethod.addHeader("Content-Type", "application/x-www-form-urlencoded");
HttpResponse httpResponse = httpClient.execute(postMethod);
String response = MQTTUtil.getResponseString(httpResponse);
if (log.isDebugEnabled()) {
log.debug(response);
}
JSONParser jsonParser = new JSONParser();
JSONObject jsonObject = (JSONObject) jsonParser.parse(response);
return (String) jsonObject.get(MQTTEventAdapterConstants.ACCESS_TOKEN_GRANT_TYPE_PARAM_NAME);
JWTClientManagerService jwtClientManagerService = InputAdapterServiceDataHolder.getJwtClientManagerService();
AccessTokenInfo accessTokenInfo = jwtClientManagerService.getJWTClient().getAccessToken(
clientId, clientSecret, username, scopes);
return accessTokenInfo.getAccessToken();
}
private String getBase64Encode(String key, String value) {

@ -34,10 +34,10 @@ public class MQTTBrokerConnectionConfiguration {
private int keepAlive;
private String brokerUrl;
private String dcrUrl;
private String tokenUrl;
private String contentValidatorClassName;
private String contentTransformerClassName;
private String contentValidatorType;
private String contentTransformerType;
private String adapterName;
private boolean globalCredentailSet;
public String getBrokerScopes() {
return brokerScopes;
@ -67,16 +67,16 @@ public class MQTTBrokerConnectionConfiguration {
return keepAlive;
}
public String getContentValidatorClassName() {
return contentValidatorClassName;
public String getContentValidatorType() {
return contentValidatorType;
}
public String getContentTransformerClassName() {
return contentTransformerClassName;
public String getContentTransformerType() {
return contentTransformerType;
}
public String getTokenUrl() {
return tokenUrl;
public boolean isGlobalCredentailSet() {
return globalCredentailSet;
}
public String getAdapterName() {
@ -89,6 +89,11 @@ public class MQTTBrokerConnectionConfiguration {
adapterName = eventAdapterConfiguration.getName();
this.username = eventAdapterConfiguration.getProperties().get(MQTTEventAdapterConstants.ADAPTER_CONF_USERNAME);
this.password = eventAdapterConfiguration.getProperties().get(MQTTEventAdapterConstants.ADAPTER_CONF_PASSWORD);
if ((username == null || username.isEmpty()) && (password == null || password.isEmpty())) {
username = globalProperties.get(MQTTEventAdapterConstants.ADAPTER_CONF_USERNAME);
password = globalProperties.get(MQTTEventAdapterConstants.ADAPTER_CONF_PASSWORD);
globalCredentailSet = true;
}
this.brokerScopes = eventAdapterConfiguration.getProperties().get(MQTTEventAdapterConstants.ADAPTER_CONF_SCOPES);
if (brokerScopes == null) {
this.brokerScopes = MQTTEventAdapterConstants.EMPTY_STRING;
@ -100,10 +105,8 @@ public class MQTTBrokerConnectionConfiguration {
this.brokerUrl = PropertyUtils.replaceMqttProperty(url);
this.dcrUrl = PropertyUtils
.replaceMqttProperty(globalProperties.get(MQTTEventAdapterConstants.ADAPTER_CONF_DCR_URL));
this.tokenUrl = PropertyUtils
.replaceMqttProperty(globalProperties.get(MQTTEventAdapterConstants.ADAPTER_CONF_TOKEN_URL));
this.contentValidatorClassName = eventAdapterConfiguration.getProperties()
.get(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME);
this.contentValidatorType = eventAdapterConfiguration.getProperties()
.get(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_VALIDATOR_TYPE);
this.cleanSession = Boolean.parseBoolean(eventAdapterConfiguration.getProperties()
.get(MQTTEventAdapterConstants.ADAPTER_CONF_CLEAN_SESSION));
//If global properties are available those will be assigned else constant values will be assigned
@ -112,7 +115,7 @@ public class MQTTBrokerConnectionConfiguration {
} else {
keepAlive = MQTTEventAdapterConstants.ADAPTER_CONF_DEFAULT_KEEP_ALIVE;
}
this.contentTransformerClassName = eventAdapterConfiguration.getProperties()
.get(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME);
this.contentTransformerType = eventAdapterConfiguration.getProperties()
.get(MQTTEventAdapterConstants.ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE);
}
}

@ -35,10 +35,10 @@ public class MQTTEventAdapterConstants {
public static final String ADAPTER_CONF_DCR_URL = "dcrUrl";
public static final String ADAPTER_CONF_TOKEN_URL = "tokenUrl";
public static final String ADAPTER_CONF_DCR_URL_HINT = "dcrUrl.hint";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME = "contentValidator";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_CLASSNAME_HINT = "contentValidator.hint";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME = "contentTransformer";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_CLASSNAME_HINT = "contentTransformer.hint";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_TYPE = "contentValidator";
public static final String ADAPTER_CONF_CONTENT_VALIDATOR_TYPE_HINT = "contentValidator.hint";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE = "contentTransformer";
public static final String ADAPTER_CONF_CONTENT_TRANSFORMER_TYPE_HINT = "contentTransformer.hint";
public static final String ADAPTER_MESSAGE_TOPIC = "topic";
public static final String ADAPTER_MESSAGE_TOPIC_HINT = "topic.hint";
public static final String ADAPTER_CONF_CLIENTID = "clientId";
@ -63,15 +63,7 @@ public class MQTTEventAdapterConstants {
public static final String MQTT_CONTENT_VALIDATION_DEFAULT_PARAMETERS = "";
public static final String TOPIC = "topic";
public static final String PAYLOAD = "payload";
public static final String DEVICE_ID_JSON_PATH = "event.metaData.deviceId";
public static final String DEVICE_TYPE_JSON_PATH = "event.metaData.deviceId";
public static final int DEVICE_ID_TOPIC_HIERARCHY_INDEX = 2;
public static final String AUTHORIZATION_HEADER_NAME = "Authorization";
public static final String AUTHORIZATION_HEADER_VALUE_PREFIX = "Basic ";
public static final String PASSWORD_GRANT_TYPE = "password";
public static final String PASSWORD_GRANT_TYPE_USERNAME = "username";
public static final String PASSWORD_GRANT_TYPE_PASSWORD = "password";
public static final String PASSWORD_GRANT_TYPE_SCOPES = "scopes";
public static final String ACCESS_TOKEN_GRANT_TYPE_PARAM_NAME = "access_token";
}

@ -18,12 +18,14 @@
package org.wso2.carbon.device.mgt.input.adapter.mqtt.util;
import org.wso2.carbon.context.PrivilegedCarbonContext;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class PropertyUtils {
private static final String TENANT_DOMAIN_PROPERTY = "\\$\\{tenant-domain\\}";
//This method is only used if the mb features are within DAS.
static String replaceMqttProperty(String urlWithPlaceholders) throws InputEventAdapterException {
@ -42,4 +44,10 @@ class PropertyUtils {
}
return urlWithPlaceholders;
}
public static String replaceTenantDomainProperty (String urlWithPlaceholders) {
urlWithPlaceholders = urlWithPlaceholders.replaceAll(TENANT_DOMAIN_PROPERTY, PrivilegedCarbonContext
.getThreadLocalCarbonContext().getTenantDomain(true));
return urlWithPlaceholders;
}
}

@ -27,14 +27,12 @@ password=Password
password.hint=Password of the user for the broker (if required)
scopes=Scopes
scopes.hint=Scopes required to connect to broker (if required)
dcrUrl=dcrUrl
dcrUrl.hint=dynamic client registration endpoint URL to create application (if required) eg: https://localhost:9443/dynamic-client-web/register
contentValidator=contentValidation
contentValidator.hint=Class Name of the content Validation or 'default' to set default class, required to implement (if required)
contentValidator.hint=Type of the content Validation or 'default' to set default type, required to implement (if required)
url.hint=MQTT broker url tcp://localhost:1883
cleanSession=Clean Session
cleanSession.hint=Persist topic subscriptions and ack positions across client sessions
keepAlive=Keep Alive (In seconds)
events.duplicated.in.cluster=Is events duplicated in cluster
contentTransformer=contentTransformer
contentTransformer.hint=Class Name of the content transformer or 'default' to set default class, required to implement (if required)
contentTransformer.hint=Type of the content transformer or 'default' to set default type, required to implement (if required)

@ -116,9 +116,16 @@
org.jivesoftware.smack.*,
org.apache.log4j,
org.wso2.carbon.base,
org.wso2.carbon.core.util
org.wso2.carbon.core.util,
org.apache.commons.logging,
org.osgi.framework,
org.osgi.service.component,
org.osgi.service.http,
org.wso2.carbon.context,
org.wso2.carbon.core,
org.wso2.carbon.device.mgt.input.adapter.extension,
org.wso2.carbon.user.core.service
</Import-Package>
<DynamicImport-Package>*</DynamicImport-Package>
</instructions>
</configuration>
</plugin>

@ -21,6 +21,7 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.service.component.ComponentContext;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.device.mgt.input.adapter.xmpp.XMPPEventAdapterFactory;
import org.wso2.carbon.event.input.adapter.core.InputEventAdapterFactory;
import org.wso2.carbon.user.core.service.RealmService;
@ -30,6 +31,11 @@ import org.wso2.carbon.user.core.service.RealmService;
* @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="input.extension.service" interface="org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService"
* cardinality="1..1"
* policy="dynamic"
* bind="setInputAdapterExtensionService"
* unbind="unsetInputAdapterExtensionService"
*/
public class InputAdapterServiceComponent {
@ -64,4 +70,12 @@ public class InputAdapterServiceComponent {
InputAdapterServiceDataHolder.registerHTTPService(null);
}
protected void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(inputAdapterExtensionService);
}
protected void unsetInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.setInputAdapterExtensionService(null);
}
}

@ -15,6 +15,7 @@
package org.wso2.carbon.device.mgt.input.adapter.xmpp.internal;
import org.osgi.service.http.HttpService;
import org.wso2.carbon.device.mgt.input.adapter.extension.InputAdapterExtensionService;
import org.wso2.carbon.user.core.service.RealmService;
/**
@ -24,6 +25,7 @@ public final class InputAdapterServiceDataHolder {
private static RealmService realmService;
private static HttpService httpService;
private static InputAdapterExtensionService inputAdapterExtensionService;
private InputAdapterServiceDataHolder() {
}
@ -46,5 +48,12 @@ public final class InputAdapterServiceDataHolder {
return httpService;
}
public static void setInputAdapterExtensionService(InputAdapterExtensionService inputAdapterExtensionService) {
InputAdapterServiceDataHolder.inputAdapterExtensionService = inputAdapterExtensionService;
}
public static InputAdapterExtensionService getInputAdapterExtensionService() {
return inputAdapterExtensionService;
}
}

@ -21,7 +21,6 @@ import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.jivesoftware.smack.ConnectionConfiguration;
import org.jivesoftware.smack.PacketListener;
import org.jivesoftware.smack.ReconnectionManager;
import org.jivesoftware.smack.SmackConfiguration;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
@ -36,9 +35,10 @@ import org.wso2.carbon.core.ServerStatus;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentInfo;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.ContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.extension.transformer.DefaultContentTransformer;
import org.wso2.carbon.device.mgt.input.adapter.extension.validator.DefaultContentValidator;
import org.wso2.carbon.device.mgt.input.adapter.xmpp.exception.XMPPContentInitializationException;
import org.wso2.carbon.device.mgt.input.adapter.xmpp.internal.InputAdapterServiceDataHolder;
import org.wso2.carbon.event.input.adapter.core.InputEventAdapterListener;
import org.wso2.carbon.event.input.adapter.core.exception.InputEventAdapterRuntimeException;
import java.util.HashMap;
@ -58,55 +58,27 @@ public class XMPPAdapterListener implements Runnable {
private InputEventAdapterListener eventAdapterListener = null;
public XMPPAdapterListener(XMPPServerConnectionConfiguration xmppServerConnectionConfiguration,
InputEventAdapterListener inputEventAdapterListener, int tenantId) {
this.xmppServerConnectionConfiguration = xmppServerConnectionConfiguration;
this.eventAdapterListener = inputEventAdapterListener;
this.tenantId = tenantId;
try {
String contentValidatorClassName = this.xmppServerConnectionConfiguration.getContentValidatorClassName();
if (contentValidatorClassName != null && contentValidatorClassName.equals(XMPPEventAdapterConstants.DEFAULT)) {
contentValidator = new DefaultContentValidator();
} else if (contentValidatorClassName != null && !contentValidatorClassName.isEmpty()) {
try {
Class<? extends ContentValidator> contentValidatorClass = Class.forName(contentValidatorClassName)
.asSubclass(ContentValidator.class);
contentValidator = contentValidatorClass.newInstance();
} catch (ClassNotFoundException e) {
throw new XMPPContentInitializationException(
"Unable to find the class validator: " + contentValidatorClassName, e);
} catch (InstantiationException e) {
throw new XMPPContentInitializationException(
"Unable to create an instance of :" + contentValidatorClassName, e);
} catch (IllegalAccessException e) {
throw new XMPPContentInitializationException("Access of the instance in not allowed.", e);
}
}
String contentValidatorType = this.xmppServerConnectionConfiguration.getContentValidatorClassName();
if (contentValidatorType == null || contentValidatorType.equals(XMPPEventAdapterConstants.DEFAULT)) {
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService().getDefaultContentValidator();
} else {
contentValidator = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentValidator(contentValidatorType);
}
String contentTransformerClassName = this.xmppServerConnectionConfiguration.getContentTransformerClassName();
if (contentTransformerClassName != null && contentTransformerClassName.equals(XMPPEventAdapterConstants.DEFAULT)) {
contentTransformer = new DefaultContentTransformer();
} else if (contentTransformerClassName != null && !contentTransformerClassName.isEmpty()) {
try {
Class<? extends ContentTransformer> contentTransformerClass = Class.forName(contentTransformerClassName)
.asSubclass(ContentTransformer.class);
contentTransformer = contentTransformerClass.newInstance();
} catch (ClassNotFoundException e) {
throw new XMPPContentInitializationException(
"Unable to find the class transformer: " + contentTransformerClassName, e);
} catch (InstantiationException e) {
throw new XMPPContentInitializationException(
"Unable to create an instance of :" + contentTransformerClassName, e);
} catch (IllegalAccessException e) {
throw new XMPPContentInitializationException("Access of the instance in not allowed.", e);
}
}
} catch (Throwable e) {
log.error("Exception occurred while subscribing to MQTT broker at "
+ xmppServerConnectionConfiguration.getHost());
throw new InputEventAdapterRuntimeException(e);
String contentTransformerType = this.xmppServerConnectionConfiguration.getContentTransformerClassName();
if (contentTransformer == null || contentTransformerType.equals(XMPPEventAdapterConstants.DEFAULT)) {
this.contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getDefaultContentTransformer();
} else {
this.contentTransformer = InputAdapterServiceDataHolder.getInputAdapterExtensionService()
.getContentTransformer(contentTransformerType);
}
}

@ -29,8 +29,8 @@ timeoutInterval.hint=used by listeners to the server and for reconnection schedu
resource=Resource
resource.hint=specific to the XMPP-Account to which the login is made to.
contentValidator=contentValidation
contentValidator.hint=Class Name of the content Validation or 'default' to set default class, required to implement (if required)
contentValidator.hint=Type of the content Validation or 'default' to set default type, required to implement (if required)
jid=jid
jid.hint=JID - XMPP Account Name.
contentTransformer=contentTransformer
contentTransformer.hint=Class Name of the content transformer or 'default' to set default class, required to implement (if required)
contentTransformer.hint=Type of the content transformer or 'default' to set default type, required to implement (if required)

@ -21,10 +21,10 @@ package org.wso2.carbon.device.mgt.output.adapter.mqtt.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
class PropertyUtils {
public class PropertyUtils {
//This method is only used if the mb features are within DAS.
static String replaceMqttProperty(String urlWithPlaceholders) {
public static String replaceMqttProperty(String urlWithPlaceholders) {
String regex = "\\$\\{(.*?)\\}";
Pattern pattern = Pattern.compile(regex);
Matcher matchPattern = pattern.matcher(urlWithPlaceholders);

@ -29,7 +29,7 @@ public class WebsocketConstants {
public static final String SCOPE_IDENTIFIER = "scopes";
public static final String MAXIMUM_TOTAL_HTTP_CONNECTION = "maximumTotalHttpConnection";
public static final String MAXIMUM_HTTP_CONNECTION_PER_HOST = "maximumHttpConnectionPerHost";
public static final String TOKEN_VALIDATION_ENDPOINT_URL = "keymanagerUrl";
public static final String TOKEN_VALIDATION_ENDPOINT_URL = "tokenValidationUrl";
public static final String TOKEN_VALIDATION_CONTEX = "/services/OAuth2TokenValidationService";
public static final String USERNAME = "username";
public static final String PASSWORD = "password";

Loading…
Cancel
Save