heartbeat configurable. Fix tests.
Change-Id: I2483f6548f906fd1cf780d63e1ce82fb2b66ca86
Signed-off-by: Ondrej Tomcik <ondrej.tomcik@kistler.com>
Reviewed-on: https://gerrit.iotivity.org/gerrit/19907
Reviewed-by: jung seungho <shonest.jung@samsung.com>
Tested-by: jenkins-iotivity <jenkins@iotivity.org>
Reviewed-by: Jee Hyeok Kim <jihyeok13.kim@samsung.com>
--- /dev/null
+FROM openjdk:8-jre
+
+ADD ./target/CloudAccount-0.0.1-SNAPSHOT.jar iotivity/AccountServer.jar
+ADD ./target/lib/* iotivity/lib/
+ADD ./properties/* iotivity/properties/
+
+WORKDIR iotivity/
+
+ENV TLS_MODE=0
+ENV MONGODB_ADDRESS=mongodb
+ENV MONGODB_PORT=27017
+
+EXPOSE 5685
+ENTRYPOINT ["java", "-jar", "AccountServer.jar"]
import java.net.InetSocketAddress;
import java.util.Scanner;
+import org.iotivity.cloud.accountserver.db.AccountDBManager;
import org.iotivity.cloud.accountserver.resources.account.AccountResource;
import org.iotivity.cloud.accountserver.resources.account.session.SessionResource;
import org.iotivity.cloud.accountserver.resources.account.tokenrefresh.TokenRefreshResource;
import org.iotivity.cloud.accountserver.resources.credprov.cert.CertificateResource;
import org.iotivity.cloud.accountserver.resources.credprov.crl.CrlResource;
import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.resource.CloudPingResource;
import org.iotivity.cloud.base.server.CoapServer;
import org.iotivity.cloud.util.Log;
*/
public class AccountServer {
+ private static int coapServerPort;
+ private static boolean tlsMode;
+ private static String databaseHost;
+ private static String webLogHost;
+
public static void main(String[] args) throws Exception {
System.out.println("-----Account SERVER-----");
-
Log.Init();
- if (!(args.length == 2 || args.length == 4)) {
- Log.e("coap server <Port> and TLS mode required\n"
- + "and WebSocketLog-Server <Address> <Port> (optional)\n"
- + "ex) 5685 0 127.0.0.1 8080\n");
+ if (!parseConfiguration(args)) {
+ Log.e("\nCoAP-server <Port> Database <Address> <Port> TLS-mode <0|1> are required. WebSocketLog-Server <Addres> <Port> is optional.\n"
+ + "ex) " + Constants.DEFAULT_COAP_PORT
+ + " 127.0.0.1 27017 0\n");
return;
}
-
- if (args.length == 4) {
- Log.InitWebLog(args[2], args[3],
+ if (webLogHost != null)
+ Log.InitWebLog(webLogHost,
AccountServer.class.getSimpleName().toString());
- }
+
+ AccountDBManager.createInstance(databaseHost);
ServerSystem serverSystem = new ServerSystem();
+ serverSystem.addResource(new CloudPingResource());
serverSystem.addResource(new AccountResource());
-
serverSystem.addResource(new SessionResource());
-
serverSystem.addResource(new TokenRefreshResource());
-
serverSystem.addResource(new GroupResource());
-
serverSystem.addResource(new AclResource());
-
serverSystem.addResource(new AclVerifyResource());
-
serverSystem.addResource(new CertificateResource());
-
serverSystem.addResource(new CrlResource());
-
serverSystem.addResource(new AclResource());
-
serverSystem.addResource(new InviteResource());
- serverSystem.addServer(new CoapServer(
- new InetSocketAddress(Integer.parseInt(args[0]))));
-
- boolean tlsMode = Integer.parseInt(args[1]) == 1;
+ serverSystem.addServer(
+ new CoapServer(new InetSocketAddress(coapServerPort)));
serverSystem.startSystem(tlsMode);
System.out.println("Terminated");
}
+
+ private static boolean parseConfiguration(String[] args) {
+ // configuration provided by arguments
+ if (args.length == 4 || args.length == 6) {
+ coapServerPort = Integer.parseInt(args[0]);
+ databaseHost = args[1] + ":" + args[2];
+ tlsMode = Integer.parseInt(args[3]) == 1;
+ if (args.length == 6)
+ webLogHost = args[4] + ":" + args[5];
+ return true;
+ }
+ // configuration provided by docker env
+ String tlsModeEnv = System.getenv("TLS_MODE");
+ if (tlsModeEnv != null) {
+
+ coapServerPort = Constants.DEFAULT_COAP_PORT;
+ databaseHost = System.getenv("MONGODB_ADDRESS") + ":"
+ + System.getenv("MONGODB_PORT");
+ tlsMode = Integer.parseInt(tlsModeEnv) == 1;
+ return true;
+ }
+ return false;
+ }
}
public class Constants extends OICConstants {
+ public static final int DEFAULT_COAP_PORT = 5685;
+
public static final String PROPERTIES_FILE_NAME = "properties"
+ File.separator + "config.properties";
*/
package org.iotivity.cloud.accountserver.db;
+import java.net.InetAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
*/
public class AccountDBManager {
- private static AccountDBManager accoutDBManager = new AccountDBManager();
-
+ private static AccountDBManager accountDBManager;
private MongoDB mongoDB;
-
private HashMap<String, ArrayList<String>> keyField = new HashMap<String, ArrayList<String>>();
- private AccountDBManager() {
-
- createDatabase();
+ private AccountDBManager(String dbHost) {
+ createDatabase(dbHost);
createTables();
createIndexes();
}
- private void createDatabase() {
+ private void createDatabase(String dbHost) {
try {
-
- mongoDB = new MongoDB(Constants.DB_NAME);
+ mongoDB = new MongoDB(dbHost, Constants.DB_NAME);
} catch (Exception e) {
e.printStackTrace();
throw new InternalServerErrorException(
* @return account DB manager
*/
public static AccountDBManager getInstance() {
+ if (accountDBManager == null)
+ accountDBManager = new AccountDBManager("127.0.0.1");
+ return accountDBManager;
+ }
- return accoutDBManager;
+ /**
+ * API to create DBManager instance with specific host
+ *
+ * @return created DB manager
+ */
+ public static AccountDBManager createInstance(String dbHost) {
+ if (accountDBManager == null)
+ accountDBManager = new AccountDBManager(dbHost);
+ return accountDBManager;
}
/**
*/
package org.iotivity.cloud.accountserver.db;
+import java.net.InetAddress;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
* @throws Exception
*/
public MongoDB(String dbname) throws Exception {
+ mongoClient = new MongoClient(InetAddress.getLocalHost().getHostAddress());
+ mongoClient.dropDatabase(dbname);
+ db = mongoClient.getDatabase(dbname);
+ }
- mongoClient = new MongoClient();
+ /**
+ * API creating MongoClient and initializing MongoDatabase
+ *
+ * @param host
+ * host of MongoDatabase
+ * @param dbname
+ * database name to create MongoDatabase
+ * @throws Exception
+ */
+ public MongoDB(String host, String dbname) throws Exception {
+ mongoClient = new MongoClient(host);
mongoClient.dropDatabase(dbname);
db = mongoClient.getDatabase(dbname);
}
--- /dev/null
+version: '3.1'
+
+services:
+ mongodb:
+ image: mongo
+
+ kafka-zookeeper:
+ image: spotify/kafka
+
+ iotivity-messagequeue:
+ image: iotivity/messagequeue
+
+ iotivity-accountserver:
+ image: iotivity/accountserver
+
+ iotivity-resourcedirectory:
+ image: iotivity/resourcedirectory
+
+ iotivity-interface:
+ image: iotivity/interface
+ ports:
+ - "5683:5683"
\ No newline at end of file
--- /dev/null
+FROM openjdk:8-jre
+
+ADD ./target/CloudInterface-0.0.1-SNAPSHOT.jar iotivity/CloudInterface.jar
+ADD ./target/lib/* iotivity/lib/
+
+WORKDIR iotivity/
+
+ENV TLS_MODE=0
+ENV KEEPALIVE_CLOUD=1
+ENV HC_PROXY_MODE=0
+ENV WEBSOCKET_MODE=0
+ENV RESOURCE_DIRECTORY_ADDRESS iotivity-resourcedirectory
+ENV ACCOUNT_SERVER_ADDRESS iotivity-accountserver
+ENV MESSAGE_QUEUE_ADDRESS iotivity-messagequeue
+
+EXPOSE 5683
+EXPOSE 80
+ENTRYPOINT ["java", "-jar", "CloudInterface.jar"]
<scope>test</scope>
</dependency>
<dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-api-mockito</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-core</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
+ <groupId>org.powermock</groupId>
+ <artifactId>powermock-module-junit4</artifactId>
+ <version>1.6.5</version>
+ <scope>test</scope>
+ </dependency>
+ <dependency>
<groupId>com.jayway.awaitility</groupId>
<artifactId>awaitility</artifactId>
<version>1.7.0</version>
public class CloudInterfaceServer {
- public static void main(String[] args) throws Exception {
-
- Log.Init();
+ private static int coapServerPort;
+ private static boolean tlsMode;
+ private static boolean keepAlive = false;
+ private static boolean hcProxyMode;
+ private static int hcProxyPort;
+ private static boolean websocketMode;
+ private static int websocketPort;
+ private static String resourceDirectoryAddress;
+ private static int resourceDirectoryPort;
+ private static String accountServerAddress;
+ private static int accountServerPort;
+ private static String messageQueueAddress;
+ private static int messageQueuePort;
+ private static String webLogHost;
+ public static void main(String[] args) throws Exception {
System.out.println("-----CI SERVER-------");
+ Log.Init();
- if (!(args.length == 10 || args.length == 12)) {
- Log.e("\nCoAP-server <Port> and RD-server <Address> <Port> Account-server <Address> <Port> "
- + "MQ-broker <Address> <Port> HC-proxy <HTTP-port> Websocket-server <Port> and TLS-mode <0|1> are required.\n"
- + "and WebSocketLog-Server <Address> <Port> (optional)\n"
- + "ex) 5683 127.0.0.1 5684 127.0.0.1 5685 127.0.0.1 5686 80 8000 0 127.0.0.1 8080\n");
+ if (!parseConfiguration(args)) {
+ Log.e("\nCoAP-server <Port> RD-server <Address> <Port> Account-server <Address> <Port> MQ-broker <Address> <Port> HC-proxy [HTTP-port] "
+ + "Websocket-server <Port> and TLS-mode <0|1> are required. WebSocketLog-Server <Addres> <Port> "
+ + "and KeepAlive for cloud components <0|1> are optional.\n"
+ + "ex) " + Constants.DEFAULT_COAP_PORT
+ + " 127.0.0.1 " + Constants.DEFAULT_RESOURCE_DIRECTORY_PORT
+ + " 127.0.0.1 " + Constants.DEFAULT_ACCOUNT_SERVER_PORT
+ + " 127.0.0.1 " + Constants.DEFAULT_MESSAGE_QUEUE_PORT
+ + " " + Constants.DEFAULT_HC_PROXY_PORT
+ + " " + Constants.DEFAULT_WEBSOCKET_PORT + " 0\n");
return;
}
-
- // CoAP-TCP server port
- int coapPort = Integer.parseInt(args[0]);
- // HTTP-CoAP proxy server port
- int hcProxyPort = Integer.parseInt(args[7]);
- // CoAP-Websocket server port
- int websocketPort = Integer.parseInt(args[8]);
-
- boolean hcProxyMode = hcProxyPort > 0;
- boolean websocketMode = websocketPort > 0;
-
- boolean tlsMode = Integer.parseInt(args[9]) == 1;
-
- if (args.length >= 11) {
- Log.InitWebLog(args[10], args[11],
+ if (webLogHost != null)
+ Log.InitWebLog(webLogHost,
CloudInterfaceServer.class.getSimpleName().toString());
- }
- ConnectorPool.addConnection("rd",
- new InetSocketAddress(args[1], Integer.parseInt(args[2])),
- tlsMode);
- ConnectorPool.addConnection("account",
- new InetSocketAddress(args[3], Integer.parseInt(args[4])),
- tlsMode);
- ConnectorPool.addConnection("mq",
- new InetSocketAddress(args[5], Integer.parseInt(args[6])),
- tlsMode);
+ ConnectorPool.requestConnection("rd",
+ new InetSocketAddress(resourceDirectoryAddress, resourceDirectoryPort),
+ tlsMode, keepAlive);
+ ConnectorPool.requestConnection("account",
+ new InetSocketAddress(accountServerAddress, accountServerPort),
+ tlsMode, keepAlive);
+ ConnectorPool.requestConnection("mq",
+ new InetSocketAddress(messageQueueAddress, messageQueuePort),
+ tlsMode, keepAlive);
DeviceServerSystem deviceServer = new DeviceServerSystem();
deviceServer.addResource(new RouteResource(devicePool));
- deviceServer.addServer(new CoapServer(new InetSocketAddress(coapPort)));
+ deviceServer.addServer(
+ new CoapServer(new InetSocketAddress(coapServerPort)));
- // Add HTTP Server for HTTP-to-CoAP Proxy
- if (hcProxyMode) {
+ if (hcProxyMode)
deviceServer.addServer(
new HttpServer(new InetSocketAddress(hcProxyPort)));
- }
- if (websocketMode) {
+ if (websocketMode)
deviceServer.addServer(
new WebSocketServer(new InetSocketAddress(websocketPort)));
- }
deviceServer.startSystem(tlsMode);
System.out.println("Terminated");
}
+
+ private static boolean parseConfiguration(String[] args) {
+ // configuration provided by arguments
+ if (args.length == 10 || args.length == 13) {
+ coapServerPort = Integer.parseInt(args[0]);
+ resourceDirectoryAddress = args[1];
+ resourceDirectoryPort = Integer.parseInt(args[2]);
+ accountServerAddress = args[3];
+ accountServerPort = Integer.parseInt(args[4]);
+ messageQueueAddress = args[5];
+ messageQueuePort = Integer.parseInt(args[6]);
+ hcProxyPort = Integer.parseInt(args[7]);
+ hcProxyMode = hcProxyPort != 0;
+ websocketPort = Integer.parseInt(args[8]);
+ websocketMode = websocketPort != 0;
+ tlsMode = Integer.parseInt(args[9]) == 1;
+ if (args.length == 13) {
+ webLogHost = args[10] + ":" + args[11];
+ keepAlive = Integer.parseInt(args[12]) == 1;
+ }
+
+ return true;
+ }
+
+ // configuration provided by docker env
+ String tlsModeEnv = System.getenv("TLS_MODE");
+ if (tlsModeEnv != null) {
+ coapServerPort = Constants.DEFAULT_COAP_PORT;
+ resourceDirectoryAddress = System.getenv("RESOURCE_DIRECTORY_ADDRESS");
+ resourceDirectoryPort = Constants.DEFAULT_RESOURCE_DIRECTORY_PORT;
+ accountServerAddress = System.getenv("ACCOUNT_SERVER_ADDRESS");
+ accountServerPort = Constants.DEFAULT_ACCOUNT_SERVER_PORT;
+ messageQueueAddress = System.getenv("MESSAGE_QUEUE_ADDRESS");
+ messageQueuePort = Constants.DEFAULT_MESSAGE_QUEUE_PORT;
+ hcProxyMode = Integer.parseInt(System.getenv("HC_PROXY_MODE")) == 1;
+ hcProxyPort = Constants.DEFAULT_HC_PROXY_PORT;
+ websocketMode = Integer.parseInt(System.getenv("WEBSOCKET_MODE")) == 1;
+ websocketPort = Constants.DEFAULT_WEBSOCKET_PORT;
+ keepAlive = Integer.parseInt(System.getenv("KEEPALIVE_CLOUD")) == 1;
+ tlsMode = Integer.parseInt(tlsModeEnv) == 1;
+
+ return true;
+ }
+ return false;
+ }
}
import org.iotivity.cloud.base.OICConstants;
public class Constants extends OICConstants {
+ public static final int DEFAULT_COAP_PORT = 5683;
+ public static final int DEFAULT_RESOURCE_DIRECTORY_PORT = 5684;
+ public static final int DEFAULT_ACCOUNT_SERVER_PORT = 5685;
+ public static final int DEFAULT_MESSAGE_QUEUE_PORT = 5686;
+ public static final int DEFAULT_HC_PROXY_PORT = 80;
+ public static final int DEFAULT_WEBSOCKET_PORT = 8000;
- public static final int MIN_TO_LIVE = 10;
+ public static final int MIN_TO_LIVE = 10;
- public static final String USER_ID = "uid";
- public static final String DEVICE_ID = "di";
- public static final String PRESENCE_STATE = "state";
+ public static final String USER_ID = "uid";
+ public static final String DEVICE_ID = "di";
+ public static final String PRESENCE_STATE = "state";
- public static final String REQ_LOGIN = "login";
+ public static final String REQ_LOGIN = "login";
- public static final String ACCESS_TOKEN = "accesstoken";
- public static final String REFRESH_TOKEN = "refreshtoken";
- public static final String AUTH_CODE = "authcode";
- public static final String AUTH_PROVIDER = "authprovider";
- public static final String EXPIRES_IN = "expiresin";
+ public static final String ACCESS_TOKEN = "accesstoken";
+ public static final String REFRESH_TOKEN = "refreshtoken";
+ public static final String AUTH_CODE = "authcode";
+ public static final String AUTH_PROVIDER = "authprovider";
+ public static final String EXPIRES_IN = "expiresin";
- public static final String REQ_GROUP_MASTER_ID = "gmid";
- public static final String REQ_MEMBER_ID = "mid";
- public static final String REQ_MEMBER_LIST = "members";
- public static final String REQ_DEVICE_ID = "di";
- public static final String REQ_DEVICE_ROUTE = "route";
- public static final String REQ_DEVICE_LIST = "devices";
- public static final String REQ_INVITE = "invite";
- public static final String REQ_PING_ARRAY = "inarray";
- public static final String REQ_PING = "in";
- public static final String REQ_SEARCH_USER_ID = "sid";
- public static final String REQ_REQUEST_METHOD = "rm";
- public static final String REQ_REQUEST_URI = "uri";
+ public static final String REQ_GROUP_MASTER_ID = "gmid";
+ public static final String REQ_MEMBER_ID = "mid";
+ public static final String REQ_MEMBER_LIST = "members";
+ public static final String REQ_DEVICE_ID = "di";
+ public static final String REQ_DEVICE_ROUTE = "route";
+ public static final String REQ_DEVICE_LIST = "devices";
+ public static final String REQ_INVITE = "invite";
+ public static final String REQ_PING_ARRAY = "inarray";
+ public static final String REQ_PING = "in";
+ public static final String REQ_SEARCH_USER_ID = "sid";
+ public static final String REQ_REQUEST_METHOD = "rm";
+ public static final String REQ_REQUEST_URI = "uri";
- public static final String REQ_GROUP_DEVICES = "devices";
+ public static final String REQ_GROUP_DEVICES = "devices";
- public static final String RESP_GRANT_POLICY = "gp";
- public static final String RESP_ACL_ALLOWED = "Allowed";
- public static final String RESP_ACL_DENIED = "Denied";
+ public static final String RESP_GRANT_POLICY = "gp";
+ public static final String RESP_ACL_ALLOWED = "Allowed";
+ public static final String RESP_ACL_DENIED = "Denied";
- public static final String REQ_LINKS = "links";
- public static final String REQ_HREF = "href";
- public static final String REQ_CRL = "crl";
+ public static final String REQ_LINKS = "links";
+ public static final String REQ_HREF = "href";
+ public static final String REQ_CRL = "crl";
}
private Cbor<HashMap<String, Object>> mCbor = new Cbor<HashMap<String, Object>>();
private HashMap<ChannelHandlerContext, CoapSignaling> mCsmMap = new HashMap<>();
- IRequestChannel mRDServer = null;
-
- public DeviceServerSystem() {
- mRDServer = ConnectorPool.getConnection("rd");
- }
-
/**
*
* This class provides a set of APIs to manage device pool.
StringBuffer uriPath = new StringBuffer();
uriPath.append("/" + Constants.PREFIX_OIC);
uriPath.append("/" + Constants.DEVICE_PRESENCE_URI);
- mRDServer.sendRequest(MessageBuilder.createRequest(
+ ConnectorPool.getConnection("rd").sendRequest(MessageBuilder.createRequest(
RequestMethod.POST, uriPath.toString(), null,
ContentFormat.APPLICATION_CBOR,
cbor.encodingPayloadToCbor(payload)), null);
public class RouteResource extends Resource {
private CoapDevicePool mDevicePool = null;
- private IRequestChannel mASServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public RouteResource(CoapDevicePool devicePool) {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.REQ_DEVICE_ROUTE));
- mASServer = ConnectorPool.getConnection("account");
mDevicePool = devicePool;
}
IRequest verifyRequest = MessageBuilder.createRequest(RequestMethod.GET,
OICConstants.ACL_VERIFY_FULL_URI, uriQuery.toString());
- mASServer.sendRequest(verifyRequest,
+ ConnectorPool.getConnection("account").sendRequest(verifyRequest,
new AccountReceiveHandler(srcDevice, request));
}
}
\ No newline at end of file
*/
public class Account extends Resource {
- IRequestChannel mASServer = null;
public Account() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACCOUNT_URI));
-
- mASServer = ConnectorPool.getConnection("account");
}
class RDReceiveHandler implements IResponseEventHandler {
class AccountReceiveHandler implements IResponseEventHandler {
- IRequestChannel mRDServer = null;
private Device mSrcDevice;
private IRequest mRequest;
public AccountReceiveHandler(IRequest request, Device srcDevice) {
- mRDServer = ConnectorPool.getConnection("rd");
mSrcDevice = srcDevice;
mRequest = request;
}
StringBuffer uriPath = new StringBuffer();
uriPath.append(Constants.PREFIX_OIC + "/");
uriPath.append(Constants.RD_URI);
- mRDServer.sendRequest(
+ ConnectorPool.getConnection("rd").sendRequest(
MessageBuilder.createRequest(RequestMethod.DELETE,
uriPath.toString(), mRequest.getUriQuery()),
new RDReceiveHandler(mRequest, response,
default:
break;
}
- mASServer.sendRequest(request,
+ ConnectorPool.getConnection("account").sendRequest(request,
new AccountReceiveHandler(request, srcDevice));
}
}
*/
public class AccountSession extends Resource {
- IRequestChannel mAuthServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public AccountSession() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACCOUNT_URI,
Constants.SESSION_URI));
-
- mAuthServer = ConnectorPool.getConnection("account");
}
@Override
ContentFormat.APPLICATION_CBOR,
mCbor.encodingPayloadToCbor(payloadData));
}
- mAuthServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(request, srcDevice);
}
}
\ No newline at end of file
*/
public class Acl extends Resource {
- IRequestChannel mAuthServer = null;
public Acl() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACL_URI));
-
- mAuthServer = ConnectorPool.getConnection("account");
}
@Override
public void onDefaultRequestReceived(Device srcDevice, IRequest request)
throws ServerException {
// Token exchange is done by CoapClient
- mAuthServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(request, srcDevice);
}
}
\ No newline at end of file
public class AclGroup extends Resource {
- private IRequestChannel mAuthServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public AclGroup() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACL_URI,
Constants.GROUP_URI));
-
- mAuthServer = ConnectorPool.getConnection("account");
}
@Override
String uriQuery = additionalQuery.toString()
+ (request.getUriQuery() != null ? (";" + request.getUriQuery())
: "");
- mAuthServer.sendRequest(MessageBuilder.modifyRequest(request, null,
- uriQuery, null, null), srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(
+ MessageBuilder.modifyRequest(request, null,
+ uriQuery, null, null), srcDevice);
}
}
\ No newline at end of file
public class AclInvite extends Resource {
- IRequestChannel mAuthServer = null;
-
public AclInvite() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.ACL_URI,
Constants.INVITE_URI));
-
- mAuthServer = ConnectorPool.getConnection("account");
-
}
@Override
request = MessageBuilder.modifyRequest(request, null, uriQuery, null,
null);
- mAuthServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(request, srcDevice);
}
}
\ No newline at end of file
*/
public class Certificate extends Resource {
- IRequestChannel mAuthServer = null;
-
public Certificate() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.CREDPROV_URI,
Constants.CERT_URI));
- mAuthServer = ConnectorPool.getConnection("account");
}
@Override
public void onDefaultRequestReceived(Device srcDevice, IRequest request)
throws ServerException {
- mAuthServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(request, srcDevice);
}
}
public class Crl extends Resource {
- private IRequestChannel mAuthServer = null;
-
public Crl() {
super(Arrays.asList(Constants.PREFIX_OIC,
Constants.CREDPROV_URI, Constants.REQ_CRL));
-
- mAuthServer = ConnectorPool.getConnection("account");
}
@Override
public void onDefaultRequestReceived(Device srcDevice, IRequest request)
throws ServerException {
// Token exchange is done by CoapClient
- mAuthServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("account").sendRequest(request, srcDevice);
}
}
\ No newline at end of file
*/
public class MessageQueue extends Resource {
- IRequestChannel mPSServer = null;
-
public MessageQueue() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.MQ_BROKER_URI));
-
- mPSServer = ConnectorPool.getConnection("mq");
}
@Override
throws ServerException {
// Token exchange is done by CoapClient
- mPSServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("mq").sendRequest(request, srcDevice);
}
}
*/
public class DevicePresence extends Resource {
- IRequestChannel mASServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public DevicePresence() {
super(Arrays.asList(Constants.PREFIX_OIC,
Constants.DEVICE_PRESENCE_URI));
-
- mASServer = ConnectorPool.getConnection("account");
}
class AccountReceiveHandler implements IResponseEventHandler {
- IRequestChannel mRDServer = null;
private Device mSrcDevice;
private IRequest mRequest;
public AccountReceiveHandler(IRequest request, Device srcDevice) {
- mRDServer = ConnectorPool.getConnection("rd");
mSrcDevice = srcDevice;
mRequest = request;
}
}
}
- mRDServer.sendRequest(mRequest, mSrcDevice);
+ ConnectorPool.getConnection("rd").sendRequest(mRequest, mSrcDevice);
break;
default:
IRequest requestToAS = MessageBuilder.createRequest(RequestMethod.GET,
uriPath.toString(), uriQuery);
- mASServer.sendRequest(requestToAS,
+ ConnectorPool.getConnection("account").sendRequest(requestToAS,
new AccountReceiveHandler(request, srcDevice));
}
}
\ No newline at end of file
public class ResourceDirectory extends Resource {
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
- IRequestChannel mRDServer = null;
- IRequestChannel mASServer = null;
public ResourceDirectory() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.RD_URI));
- mRDServer = ConnectorPool.getConnection("rd");
- mASServer = ConnectorPool.getConnection("account");
}
@Override
query.toString(), ContentFormat.APPLICATION_CBOR,
mCbor.encodingPayloadToCbor(requestPayload));
- mASServer.sendRequest(requestToAS,
+ ConnectorPool.getConnection("account").sendRequest(requestToAS,
new AccountReceiveHandler(request, srcDevice));
break;
case DELETE:
- mRDServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("rd").sendRequest(request, srcDevice);
break;
default:
null, ContentFormat.APPLICATION_CBOR,
convertedPayload);
- mRDServer.sendRequest(mRequest,
+ ConnectorPool.getConnection("rd").sendRequest(mRequest,
new PublishResponseHandler(mSrcDevice));
break;
*/
public class ResourceFind extends Resource {
- IRequestChannel mASServer = null;
- IRequestChannel mRDServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public ResourceFind() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.WELL_KNOWN_URI));
-
- mASServer = ConnectorPool.getConnection("account");
- mRDServer = ConnectorPool.getConnection("rd");
}
class AccountReceiveHandler implements IResponseEventHandler {
mRequest = MessageBuilder.modifyRequest(mRequest, null,
uriQuery, null, null);
- mRDServer.sendRequest(mRequest, mSrcDevice);
+ ConnectorPool.getConnection("rd").sendRequest(mRequest, mSrcDevice);
break;
default:
if (request.getUriQuery() != null && request.getUriQueryMap()
.containsKey(Constants.REQ_DEVICE_ID)) {
- mRDServer.sendRequest(request, srcDevice);
+ ConnectorPool.getConnection("rd").sendRequest(request, srcDevice);
} else {
StringBuffer additionalQuery = new StringBuffer();
IRequest requestToAS = MessageBuilder.createRequest(
RequestMethod.GET, uriPath.toString(), uriQuery);
- mASServer.sendRequest(requestToAS,
+ ConnectorPool.getConnection("account").sendRequest(requestToAS,
new AccountReceiveHandler(request, srcDevice));
}
}
*/
public class ResourcePresence extends Resource {
- IRequestChannel mASServer = null;
private Cbor<HashMap<String, Object>> mCbor = new Cbor<>();
public ResourcePresence() {
super(Arrays.asList(Constants.PREFIX_OIC, Constants.RES_PRESENCE_URI));
-
- mASServer = ConnectorPool.getConnection("account");
}
class AccountReceiveHandler implements IResponseEventHandler {
- IRequestChannel mRDServer = null;
private Device mSrcDevice;
private IRequest mRequest;
public AccountReceiveHandler(IRequest request, Device srcDevice) {
- mRDServer = ConnectorPool.getConnection("rd");
mSrcDevice = srcDevice;
mRequest = request;
}
mRequest = MessageBuilder.modifyRequest(mRequest, null,
uriQuery, null, null);
- mRDServer.sendRequest(mRequest, mSrcDevice);
+ ConnectorPool.getConnection("rd").sendRequest(mRequest, mSrcDevice);
}
break;
IRequest requestToAS = MessageBuilder.createRequest(RequestMethod.GET,
uriPath.toString(), uriQuery);
- mASServer.sendRequest(requestToAS,
+ ConnectorPool.getConnection("account").sendRequest(requestToAS,
new AccountReceiveHandler(request, srcDevice));
}
}
\ No newline at end of file
import java.util.concurrent.CountDownLatch;
import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.Device;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.util.Log;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import io.netty.channel.ChannelId;
import io.netty.channel.ChannelPromise;
import io.netty.util.Attribute;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class DeviceServerSystemTest {
private ChannelHandlerContext mCtx = null;
private ChannelHandlerContext mCtxSignal = null;
}
}).when(mCtx).writeAndFlush(Mockito.any());
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class RouteResourceTest {
private static final String RELAY_URI = "/di";
private static final String RESOURCE_URI = "/a/light/0";
}
}).when(mRequestChannelASServer).sendRequest(
Mockito.any(IRequest.class), Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannelASServer);
}
@Test
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class AccountSessionTest {
private String mDi = "B371C481-38E6-4D47-8320-7688D8A5B58C";
public static final String SESSION_URI = Constants.ACCOUNT_SESSION_FULL_URI;
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class AccountTest {
private String mDi = "B371C481-38E6-4D47-8320-7688D8A5B58C";
public static final String ACCOUNT_URI = Constants.ACCOUNT_FULL_URI;
}
}).when(mRequestChannelASServer).sendRequest(
Mockito.any(IRequest.class), Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection("account")).thenReturn(mRequestChannelASServer);
+ PowerMockito.when(ConnectorPool.getConnection("rd")).thenReturn(mRequestChannelRDServer);
}
@Test
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.exception.ServerException.BadRequestException;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class AclGroupTest {
private static final String TEST_RESOURCE_GROUP_URI = Constants.GROUP_FULL_URI;
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class AclInviteTest {
private static final String TEST_RESOURCE_INVITE_URI = Constants.INVITE_FULL_URI;
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.concurrent.CountDownLatch;
import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.ciserver.DeviceServerSystem;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class AclTest {
private static final String TEST_RESOURCE_ACI_URI = "/"
+ OICConstants.PREFIX_OIC + "/" + OICConstants.ACL_URI;
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.concurrent.CountDownLatch;
import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.ciserver.DeviceServerSystem;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class CertificateTest {
private static final String TEST_RESOURCE_CERTI_URI = "/"
+ OICConstants.PREFIX_OIC + "/" + OICConstants.CREDPROV_URI + "/"
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.concurrent.CountDownLatch;
import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.ciserver.DeviceServerSystem;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class CrlTest {
private static final String TEST_RESOURCE_CRL_URI = "/"
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class MessageQueueTest {
private static final String TEST_MQ_BROKER_URI = Constants.MQ_BROKER_FULL_URI;
private CoapDevice mMockDevice = null;
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
import java.util.List;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.exception.ClientException;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class DevicePresenceTest {
private static final String DEVICE_PRS_REQ_URI = Constants.DEVICE_PRESENCE_FULL_URI;
private String mDi = "B371C481-38E6-4D47-8320-7688D8A5B58C";
}
}).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
// @InjectMocks for testSpecificDeviceonResponseReceived
import java.util.HashMap;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.protocols.IRequest;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class ResourceDirectoryTest {
private static final String TEST_RD_URI = Constants.RD_FULL_URI;
public static final String DEVICE_LIST_KEY = "devices";
}).when(mRequestChannelASServer).sendRequest(
Mockito.any(IRequest.class), Mockito.any(CoapDevice.class));
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection("account")).thenReturn(mRequestChannelASServer);
+ PowerMockito.when(ConnectorPool.getConnection("rd")).thenReturn(mRequestChannelRDServer);
}
@Test
import java.util.List;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.exception.ClientException;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class ResourceFindTest {
private static final String TEST_RESOURCE_FIND_URI = Constants.WELL_KNOWN_FULL_URI;
private String di = "B371C481-38E6-4D47-8320-7688D8A5B58C";
}
}).when(mRequestChannelASServer).sendRequest(
Mockito.any(IRequest.class), Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection("account")).thenReturn(mRequestChannelASServer);
+ PowerMockito.when(ConnectorPool.getConnection("rd")).thenReturn(mRequestChannelRDServer);
}
// @InjectMocks for testSpecificDeviceonResponseReceived
import java.util.List;
import java.util.concurrent.CountDownLatch;
+import org.iotivity.cloud.base.connector.ConnectorPool;
import org.iotivity.cloud.base.device.CoapDevice;
import org.iotivity.cloud.base.device.IRequestChannel;
import org.iotivity.cloud.base.exception.ClientException;
import org.iotivity.cloud.util.Cbor;
import org.junit.Before;
import org.junit.Test;
+import org.junit.runner.RunWith;
import org.mockito.InjectMocks;
import org.mockito.Mock;
import org.mockito.Mockito;
import org.mockito.MockitoAnnotations;
import org.mockito.invocation.InvocationOnMock;
import org.mockito.stubbing.Answer;
+import org.powermock.api.mockito.PowerMockito;
+import org.powermock.core.classloader.annotations.PrepareForTest;
+import org.powermock.modules.junit4.PowerMockRunner;
+@RunWith(PowerMockRunner.class)
+@PrepareForTest(ConnectorPool.class)
public class ResourcePresenceTest {
public static final String DEVICE_PRS_REQ_URI = Constants.DEVICE_PRESENCE_FULL_URI;
public static final String RES_PRS_URI = Constants.RESOURCE_PRESENCE_FULL_URI;
private DeviceServerSystem deviceServerSystem = new DeviceServerSystem();
final CountDownLatch latch = new CountDownLatch(1);
@Mock
- private IRequestChannel requestChannel;
+ private IRequestChannel mRequestChannel;
@InjectMocks
private ResourcePresence adHandler = new ResourcePresence();
latch.countDown();
return request;
}
- }).when(requestChannel).sendRequest(Mockito.any(IRequest.class),
+ }).when(mRequestChannel).sendRequest(Mockito.any(IRequest.class),
Mockito.any(CoapDevice.class));
+
+ PowerMockito.mockStatic(ConnectorPool.class);
+ PowerMockito.when(ConnectorPool.getConnection(Mockito.anyString())).thenReturn(mRequestChannel);
}
@Test
--- /dev/null
+FROM openjdk:8-jre
+
+ADD ./target/CloudMessageQueue-0.0.1-SNAPSHOT.jar iotivity/MessageQueue.jar
+ADD ./target/lib/* iotivity/lib/
+
+WORKDIR iotivity/
+
+ENV TLS_MODE=0
+ENV ZOOKEEPER_ADDRESS kafka-zookeeper
+ENV ZOOKEEPER_PORT 2181
+ENV KAFKA_ADDRESS kafka-zookeeper
+ENV KAFKA_PORT 9092
+
+EXPOSE 5686
+ENTRYPOINT ["java", "-jar", "MessageQueue.jar"]
\ No newline at end of file
import org.iotivity.cloud.base.OICConstants;
public class Constants extends OICConstants {
+ public static final int DEFAULT_COAP_PORT = 5686;
public static final String MQ_TOPICLIST = "topiclist";
import java.util.Scanner;
import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.resource.CloudPingResource;
import org.iotivity.cloud.base.server.CoapServer;
import org.iotivity.cloud.mqserver.resources.MQBrokerResource;
import org.iotivity.cloud.util.Log;
public class MessageQueueServer {
- public static void main(String[] args) throws Exception {
- Log.Init();
+ private static int coapServerPort;
+ private static boolean tlsMode;
+ private static String zookeeperHost;
+ private static String kafkaHost;
+ private static String webLogHost;
+ public static void main(String[] args) throws Exception {
System.out.println("-----MQ SERVER-----");
+ Log.Init();
- if (!(args.length == 6 || args.length == 8)) {
- Log.e("coap server port, Kafka_zookeeper_Address port"
- + " and Kafka_broker_Address Port and TLS mode required\n"
- + " and WebSocketLog-Server <Address> <Port> (optional)\n"
- + "ex) 5686 127.0.0.1 2181 127.0.0.1 9092 0 127.0.0.1 8080\n");
-
+ if (!parseConfiguration(args)) {
+ Log.e("\nCoAP-server <Port> Zookeeper <Address> <Port> Kafka <Address> <Port> TLS-mode <0|1> are required. "
+ + "WebSocketLog-Server <Addres> <Port> is optional.\n"
+ + "ex) " + Constants.DEFAULT_COAP_PORT
+ + " 127.0.0.1 2181 127.0.0.1 9092 0\n");
return;
}
-
- if (args.length == 8) {
- Log.InitWebLog(args[6], args[7],
+ if (webLogHost != null)
+ Log.InitWebLog(webLogHost,
MessageQueueServer.class.getSimpleName().toString());
- }
ServerSystem serverSystem = new ServerSystem();
MQBrokerResource MQBroker = new MQBrokerResource();
-
- String kafka_zookeeper = args[1] + ":" + args[2];
- String kafka_broker = args[3] + ":" + args[4];
- MQBroker.setKafkaInformation(kafka_zookeeper, kafka_broker);
+ MQBroker.setKafkaInformation(zookeeperHost, kafkaHost);
serverSystem.addResource(MQBroker);
+ serverSystem.addResource(new CloudPingResource());
- serverSystem.addServer(new CoapServer(
- new InetSocketAddress(Integer.parseInt(args[0]))));
-
- boolean tlsMode = Integer.parseInt(args[5]) == 1;
+ serverSystem.addServer(
+ new CoapServer(new InetSocketAddress(coapServerPort)));
serverSystem.startSystem(tlsMode);
System.out.println("Terminated");
}
+
+ private static boolean parseConfiguration(String[] args) {
+ // configuration provided by arguments
+ if (args.length == 6 || args.length == 8) {
+ coapServerPort = Integer.parseInt(args[0]);
+ zookeeperHost = args[1] + ":" + args[2];
+ kafkaHost = args[3] + ":" + args[4];
+ tlsMode = Integer.parseInt(args[5]) == 1;
+ if (args.length == 8)
+ webLogHost = args[6] + ":" + args[7];
+ return true;
+ }
+ // configuration provided by docker env
+ String tlsModeEnv = System.getenv("TLS_MODE");
+ if (tlsModeEnv != null) {
+ coapServerPort = Constants.DEFAULT_COAP_PORT;
+ tlsMode = Integer.parseInt(tlsModeEnv) == 1;
+ zookeeperHost = System.getenv("ZOOKEEPER_ADDRESS") + ":"
+ + System.getenv("ZOOKEEPER_PORT");
+ kafkaHost = System.getenv("KAFKA_ADDRESS") + ":"
+ + System.getenv("KAFKA_PORT");
+ return true;
+ }
+ return false;
+ }
}
\ No newline at end of file
--- /dev/null
+FROM openjdk:8-jre
+
+ADD ./target/CloudResourceDirectory-0.0.1-SNAPSHOT.jar iotivity/ResourceDirectory.jar
+ADD ./target/lib/* iotivity/lib/
+
+WORKDIR iotivity/
+
+ENV TLS_MODE=0
+ENV MONGODB_ADDRESS mongodb
+ENV MONGODB_PORT 27017
+
+EXPOSE 5684
+ENTRYPOINT ["java", "-jar", "ResourceDirectory.jar"]
\ No newline at end of file
public class Constants extends OICConstants {
+ public static final int DEFAULT_COAP_PORT = 5684;
+
/** Database, Table name */
public static final String RD_DB_NAME = "RD_DB";
public static final String RD_TABLE = "RD_TABLE";
import java.util.Scanner;
import org.iotivity.cloud.base.ServerSystem;
+import org.iotivity.cloud.base.resource.CloudPingResource;
import org.iotivity.cloud.base.server.CoapServer;
+import org.iotivity.cloud.rdserver.db.DBManager;
import org.iotivity.cloud.rdserver.resources.directory.rd.ResourceDirectoryResource;
import org.iotivity.cloud.rdserver.resources.directory.res.DiscoveryResource;
import org.iotivity.cloud.rdserver.resources.presence.device.DevicePresenceResource;
*/
public class ResourceDirectoryServer {
- public static void main(String[] args) throws Exception {
- Log.Init();
+ private static int coapServerPort;
+ private static boolean tlsMode;
+ private static String databaseHost;
+ private static String webLogHost;
+ public static void main(String[] args) throws Exception {
System.out.println("-----RD SERVER-----");
+ Log.Init();
- if (!(args.length != 2 || args.length != 4)) {
- Log.e("coap server port and TLS mode required\n" + "ex) 5684 0\n");
+ if (!parseConfiguration(args)) {
+ Log.e("\nCoAP-server <Port> Database <Address> <Port> TLS-mode <0|1> are required. WebSocketLog-Server <Addres> <Port> is optional.\n"
+ + "ex) " + Constants.DEFAULT_COAP_PORT
+ + " 127.0.0.1 27017 0\n");
return;
}
-
- if (args.length == 4) {
- Log.InitWebLog(args[2], args[3],
+ if (webLogHost != null)
+ Log.InitWebLog(webLogHost,
ResourceDirectoryServer.class.getSimpleName().toString());
- }
+
+ DBManager.createInstance(databaseHost);
ServerSystem serverSystem = new ServerSystem();
+ serverSystem.addResource(new CloudPingResource());
serverSystem.addResource(new ResourceDirectoryResource());
serverSystem.addResource(new DiscoveryResource());
serverSystem.addResource(new DevicePresenceResource());
serverSystem.addResource(new ResPresenceResource());
- serverSystem.addServer(new CoapServer(
- new InetSocketAddress(Integer.parseInt(args[0]))));
-
- boolean tlsMode = Integer.parseInt(args[1]) == 1;
+ serverSystem.addServer(
+ new CoapServer(new InetSocketAddress(coapServerPort)));
serverSystem.startSystem(tlsMode);
System.out.println("Terminated");
}
+
+ private static boolean parseConfiguration(String[] args) {
+ // configuration provided by arguments
+ if (args.length == 4 || args.length == 6) {
+ coapServerPort = Integer.parseInt(args[0]);
+ databaseHost = args[1] + ":" + args[2];
+ tlsMode = Integer.parseInt(args[3]) == 1;
+ if (args.length == 6)
+ webLogHost = args[4] + ":" + args[5];
+ return true;
+ }
+ // configuration provided by docker env
+ String tlsModeEnv = System.getenv("TLS_MODE");
+ if (tlsModeEnv != null) {
+ coapServerPort = Constants.DEFAULT_COAP_PORT;
+ databaseHost = System.getenv("MONGODB_ADDRESS") + ":"
+ + System.getenv("MONGODB_PORT");
+ tlsMode = Integer.parseInt(tlsModeEnv) == 1;
+ return true;
+ }
+ return false;
+ }
}
*/
public class DBManager {
- private static DBManager mDBManager = new DBManager();
+ private static DBManager mDBManager;
private MongoDB mMongoDB = null;
private HashMap<String, ArrayList<String>> mKeyField = new HashMap<>();
- private DBManager() {
- createDatabase();
+ private DBManager(String dbHost) {
+ createDatabase(dbHost);
createTables();
createIndexes();
}
* @return DBManager DBManager object
*/
public static DBManager getInstance() {
+ if (mDBManager == null)
+ mDBManager = new DBManager("127.0.0.1");
return mDBManager;
}
- private void createDatabase() {
+ /**
+ * API to create DBManager instance with specific host
+ *
+ * @return created DB manager
+ */
+ public static DBManager createInstance(String dbHost) {
+ if (mDBManager == null)
+ mDBManager = new DBManager(dbHost);
+ return mDBManager;
+ }
+ private void createDatabase(String dbHost) {
try {
-
- mMongoDB = new MongoDB(Constants.RD_DB_NAME);
+ mMongoDB = new MongoDB(dbHost, Constants.RD_DB_NAME);
} catch (Exception e) {
e.printStackTrace();
throw new InternalServerErrorException("Database create failed!");
/**
* API creating MongoClient and initializing MongoDatabase
*
+ * @param host
+ * host of MongoDatabase
* @param dbname
* database name to create MongoDatabase
* @throws Exception
*/
- public MongoDB(String dbname) throws Exception {
+ public MongoDB(String host, String dbname) throws Exception {
- mongoClient = new MongoClient();
+ mongoClient = new MongoClient(host);
mongoClient.dropDatabase(dbname);
db = mongoClient.getDatabase(dbname);
}
}
public static void resetRDDatabase() throws Exception {
- MongoDB mongoDB = new MongoDB(Constants.RD_DB_NAME);
+ MongoDB mongoDB = new MongoDB("127.0.0.1", Constants.RD_DB_NAME);
mongoDB.createTable(Constants.RD_TABLE);
mongoDB.createTable(Constants.PRESENCE_TABLE);
}
/* resource uri for message queue */
public static final String MQ_BROKER_URI = "ps";
-
+
/* file path for tls communication - Modify filePath to yours */
- public static final String ROOT_CERT_FILE = "../certificate/rootca.crt";
+ public static final String CERTS_PATH = "../certificate";
+
+ public static final String ROOT_CERT_FILE = CERTS_PATH + "/rootca.crt";
- public static final String CLOUD_CERT_FILE = "../certificate/iotivitycloud.crt";
+ public static final String CLOUD_CERT_FILE = CERTS_PATH + "/iotivitycloud.crt";
- public static final String CLOUD_KEY_FILE = "../certificate/iotivitycloud.key";
+ public static final String CLOUD_KEY_FILE = CERTS_PATH + "/iotivitycloud.key";
/* cloud uuid */
public static final String CLOUD_UUID = "2a6085d1-815d-4277-baba-4e4e4df91308";
public static final String CREDPROV_CERT_FULL_URI = "/" + PREFIX_OIC
+ "/" + CREDPROV_URI + "/" + CERT_URI;
-}
+}
\ No newline at end of file
*/
package org.iotivity.cloud.base.connector;
-import java.io.File;
-import java.net.InetSocketAddress;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-
-import javax.net.ssl.SSLException;
-
-import org.iotivity.cloud.base.OICConstants;
-import org.iotivity.cloud.base.protocols.coap.CoapDecoder;
-import org.iotivity.cloud.base.protocols.coap.CoapEncoder;
-import org.iotivity.cloud.base.protocols.coap.CoapLogHandler;
-import org.iotivity.cloud.base.protocols.coap.CoapResponse;
-
import io.netty.bootstrap.Bootstrap;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelHandler;
+import io.netty.channel.*;
import io.netty.channel.ChannelHandler.Sharable;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelOption;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.EventLoopGroup;
-import io.netty.channel.SimpleChannelInboundHandler;
import io.netty.channel.nio.NioEventLoopGroup;
import io.netty.channel.socket.SocketChannel;
import io.netty.channel.socket.nio.NioSocketChannel;
import io.netty.handler.ssl.SslContext;
import io.netty.handler.ssl.SslContextBuilder;
import io.netty.handler.ssl.SslProvider;
+import io.netty.handler.timeout.IdleState;
+import io.netty.handler.timeout.IdleStateEvent;
+import io.netty.handler.timeout.IdleStateHandler;
+import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.protocols.coap.*;
+import org.iotivity.cloud.base.protocols.coap.PingMessage;
+import org.iotivity.cloud.util.Log;
+
+import javax.net.ssl.SSLException;
+import java.io.File;
+import java.net.InetSocketAddress;
+import java.util.*;
public class CoapConnector {
}
}
+ public static class KeepAliveHandler extends ChannelDuplexHandler {
+ @Override
+ public void userEventTriggered(ChannelHandlerContext ctx, Object evt)
+ throws Exception {
+ if (evt instanceof IdleStateEvent) {
+ IdleStateEvent event = (IdleStateEvent) evt;
+ if (event.state() == IdleState.WRITER_IDLE) {
+ ctx.writeAndFlush(PingMessage.build());
+ }
+ if (event.state() == IdleState.READER_IDLE) {
+ Log.d("Connection with" + ctx.channel().remoteAddress().toString() + "is idle. Closing connection.");
+ ctx.close();
+ }
+ }
+ }
+ }
+
public static class CoapConnectorInitializer
extends ChannelInitializer<SocketChannel> {
private List<ChannelHandler> additionalHandlers = new ArrayList<>();
private Boolean mTlsMode = false;
+ private Boolean mKeepAlive = false;
InetSocketAddress mInetSocketAddress = null;
String mRootCertFiePath = null;
this.mTlsMode = tlsMode;
}
+ public void setKeepAlive(Boolean keepAlive) {
+ this.mKeepAlive = keepAlive;
+ }
+
public void setInetSocketAddress(InetSocketAddress address) {
this.mInetSocketAddress = address;
}
p.addLast(new CoapDecoder());
p.addLast(new CoapEncoder());
p.addLast(new CoapLogHandler());
+
+ if (mKeepAlive.equals(true)) {
+ p.addLast(new IdleStateHandler(100, 45, 0));
+ p.addLast(new KeepAliveHandler());
+ }
+
for (ChannelHandler handler : additionalHandlers) {
p.addLast(handler);
}
}
HashMap<Channel, CoapClient> mChannelMap = new HashMap<>();
-
Bootstrap mBootstrap = new Bootstrap();
EventLoopGroup mConnectorGroup = new NioEventLoopGroup();
+ Timer mTimer = new Timer();
- public CoapClient connect(final InetSocketAddress inetSocketAddress,
- boolean tlsMode) throws InterruptedException {
+ public void connect(final String connectionName, final InetSocketAddress inetSocketAddress,
+ boolean tlsMode, boolean keepAlive) {
CoapConnectorInitializer initializer = new CoapConnectorInitializer();
initializer.setRootCertFilePath(OICConstants.ROOT_CERT_FILE);
}
+ initializer.setKeepAlive(keepAlive);
initializer.addHandler(new CoapPacketHandler());
mBootstrap.handler(initializer);
+ doConnect(connectionName, inetSocketAddress, tlsMode);
+ }
+
+ private void doConnect(final String connectionName, final InetSocketAddress inetSocketAddress, final boolean tlsMode) {
+ mBootstrap.connect(inetSocketAddress).addListener(new ChannelFutureListener() {
+ @Override public void operationComplete(ChannelFuture future) throws Exception {
+ if(!future.isSuccess()) {
+ Log.d("Connection to " + inetSocketAddress.getHostString() + " was not successful. Retrying...");
+ future.channel().close();
+ scheduleConnect(connectionName, inetSocketAddress, tlsMode, 5000);
+ } else {
+ connectionEstablished(connectionName, future.channel());
+ addCloseDetectListener(future.channel());
+ }
+ }
- ChannelFuture channelFuture = null;
- channelFuture = mBootstrap.connect(inetSocketAddress).sync();
+ private void addCloseDetectListener(Channel channel) {
+ channel.closeFuture().addListener((ChannelFutureListener) future -> {
+ Log.d("Connection to " + inetSocketAddress.getHostString() + " was lost. Retrying...");
+ scheduleConnect(connectionName, inetSocketAddress, tlsMode, 5);
+ });
+ }
+ });
+ }
- CoapClient coapClient = null;
- coapClient = new CoapClient(channelFuture.channel());
- mChannelMap.put(channelFuture.channel(), coapClient);
+ private void scheduleConnect(String connectionName, InetSocketAddress inetSocketAddress, boolean tlsMode, long millis) {
+ mTimer.schedule( new TimerTask() {
+ @Override
+ public void run() {
+ doConnect(connectionName, inetSocketAddress, tlsMode);
+ }
+ }, millis );
+ }
- return coapClient;
+ public void connectionEstablished(String connectionName, Channel channel) {
+ CoapClient coapClient = new CoapClient(channel);
+ mChannelMap.put(channel, coapClient);
+ ConnectorPool.addConnection(connectionName, coapClient);
}
public void disconenct() throws Exception {
import java.net.InetSocketAddress;
import java.util.ArrayList;
-import java.util.HashMap;
+import java.util.concurrent.ConcurrentHashMap;
import org.iotivity.cloud.base.device.IRequestChannel;
public class ConnectorPool {
- static HashMap<String, IRequestChannel> mConnection = new HashMap<>();
+ static ConcurrentHashMap<String, IRequestChannel> mConnection = new ConcurrentHashMap<>();
static CoapConnector mConnector = new CoapConnector();
}
- public static void addConnection(String name, InetSocketAddress inetAddr,
- boolean tlsMode) throws InterruptedException {
- mConnection.put(name, mConnector.connect(inetAddr, tlsMode));
+ public static void requestConnection(String connectionName, InetSocketAddress inetAddr,
+ boolean tlsMode, boolean keepAlive) throws InterruptedException {
+ mConnector.connect(connectionName, inetAddr, tlsMode, keepAlive);
}
public static IRequestChannel getConnection(String name) {
public static ArrayList<IRequestChannel> getConnectionList() {
return new ArrayList<IRequestChannel>(mConnection.values());
}
+
+ public static void addConnection(String name, IRequestChannel requestChannel) {
+ if (mConnection.containsKey(name))
+ mConnection.remove(name);
+ mConnection.put(name, requestChannel);
+ }
}
--- /dev/null
+package org.iotivity.cloud.base.protocols.coap;
+
+import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.protocols.enums.RequestMethod;
+
+public final class PingMessage extends CoapRequest {
+ public PingMessage() {
+ super(RequestMethod.PUT);
+ setUriPath(OICConstants.KEEP_ALIVE_FULL_URI);
+ }
+
+ public static PingMessage build() {
+ return new PingMessage();
+ }
+}
+
--- /dev/null
+package org.iotivity.cloud.base.resource;
+
+import org.iotivity.cloud.base.OICConstants;
+import org.iotivity.cloud.base.device.Device;
+import org.iotivity.cloud.base.exception.ServerException;
+import org.iotivity.cloud.base.protocols.IRequest;
+import org.iotivity.cloud.base.protocols.IResponse;
+import org.iotivity.cloud.base.protocols.MessageBuilder;
+import org.iotivity.cloud.base.protocols.enums.ResponseStatus;
+
+import java.util.Arrays;
+
+public class CloudPingResource extends Resource {
+ public CloudPingResource() {
+ super(Arrays.asList(OICConstants.PREFIX_OIC, OICConstants.KEEP_ALIVE_URI));
+ }
+
+ @Override
+ public void onDefaultRequestReceived(Device srcDevice, IRequest request)
+ throws ServerException {
+
+ IResponse response;
+ switch (request.getMethod()) {
+ case PUT:
+ response = MessageBuilder.createResponse(request, ResponseStatus.VALID);
+ break;
+
+ default:
+ throw new ServerException.BadRequestException(
+ request.getMethod() + " request type is not support");
+ }
+ srcDevice.sendResponse(response);
+ }
+}
createfile();
}
- public static void InitWebLog(String weblogHostname, String port,
- String serverName) {
+ public static void InitWebLog(String webLogHost, String serverName) {
mServerName = serverName;
-
- if (weblogHostname != null) {
+ if (webLogHost != null) {
try {
- String LogServerAddr = "ws://" + weblogHostname + ":" + port;
- websocketpoint = new WebsocketLog(new URI(LogServerAddr));
+ websocketpoint = new WebsocketLog(new URI("ws://" + webLogHost));
websocketpoint.start();
} catch (Exception e) {
System.out.println(e.getMessage());
projects / platform / upstream / iotivity.git / commitdiff