Fixed conflicts in merge

revert-70aa11f8
harshanL 10 years ago
commit 771575c408

@ -0,0 +1,27 @@
/**
* Copyright (c) 2015, 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.core;
public final class DeviceManagementConstants {
public static final class Common {
private Common() {
throw new AssertionError();
}
public static final String PROPERTY_SETUP = "setup";
}
}

@ -35,19 +35,26 @@ public class DeviceManagementRepository {
public void addDeviceManagementProvider(DeviceManagerService provider) { public void addDeviceManagementProvider(DeviceManagerService provider) {
String deviceType = provider.getProviderType(); String deviceType = provider.getProviderType();
providers.put(deviceType, provider);
try { try {
DeviceManagerUtil.registerDeviceType(deviceType); DeviceManagerUtil.registerDeviceType(deviceType);
} catch (DeviceManagementException e) { } catch (DeviceManagementException e) {
log.error("Exception occured while registering the device type.",e); log.error("Exception occurred while registering the device type.", e);
} }
providers.put(deviceType, provider);
}
public void removeDeviceManagementProvider(DeviceManagerService provider) {
String deviceType = provider.getProviderType();
try {
DeviceManagerUtil.unregisterDeviceType(deviceType);
} catch (DeviceManagementException e) {
log.error("Exception occurred while registering the device type.", e);
}
providers.remove(deviceType);
} }
public DeviceManagerService getDeviceManagementProvider(String type) { public DeviceManagerService getDeviceManagementProvider(String type) {
return providers.get(type); return providers.get(type);
} }
public Map<String, DeviceManagerService> getProviders() {
return providers;
}
} }

@ -28,7 +28,7 @@ public final class DeviceManagementConfig {
private DeviceManagementRepository deviceMgtRepository; private DeviceManagementRepository deviceMgtRepository;
@XmlElement(name = "ManagementRepository", nillable = false) @XmlElement(name = "ManagementRepository", required = true)
public DeviceManagementRepository getDeviceMgtRepository() { public DeviceManagementRepository getDeviceMgtRepository() {
return deviceMgtRepository; return deviceMgtRepository;
} }

@ -29,7 +29,7 @@ public class DeviceManagementRepository {
private DataSourceConfig dataSourceConfig; private DataSourceConfig dataSourceConfig;
@XmlElement(name = "DataSourceConfiguration", nillable = false) @XmlElement(name = "DataSourceConfiguration", required = false)
public DataSourceConfig getDataSourceConfig() { public DataSourceConfig getDataSourceConfig() {
return dataSourceConfig; return dataSourceConfig;
} }

@ -21,14 +21,14 @@ import javax.xml.bind.annotation.XmlElement;
import javax.xml.bind.annotation.XmlRootElement; import javax.xml.bind.annotation.XmlRootElement;
/** /**
* Class for holding data source configuration in cdm-config.xml at parsing with JAXB * Class for holding data source configuration in malformed-cdm-config-no-mgt-repo.xml at parsing with JAXB
*/ */
@XmlRootElement(name = "DataSourceConfiguration") @XmlRootElement(name = "DataSourceConfiguration")
public class DataSourceConfig { public class DataSourceConfig {
private JNDILookupDefinition jndiLookupDefintion; private JNDILookupDefinition jndiLookupDefintion;
@XmlElement(name = "JndiLookupDefinition", nillable = true) @XmlElement(name = "JndiLookupDefinition", required = true)
public JNDILookupDefinition getJndiLookupDefintion() { public JNDILookupDefinition getJndiLookupDefintion() {
return jndiLookupDefintion; return jndiLookupDefintion;
} }

@ -27,7 +27,7 @@ public class JNDILookupDefinition {
private String jndiName; private String jndiName;
private List<JNDIProperty> jndiProperties; private List<JNDIProperty> jndiProperties;
@XmlElement(name = "Name", nillable = false) @XmlElement(name = "Name", required = false)
public String getJndiName() { public String getJndiName() {
return jndiName; return jndiName;
} }
@ -36,7 +36,7 @@ public class JNDILookupDefinition {
this.jndiName = jndiName; this.jndiName = jndiName;
} }
@XmlElementWrapper(name = "Environment", nillable = false) @XmlElementWrapper(name = "Environment", required = false)
@XmlElement(name = "Property", nillable = false) @XmlElement(name = "Property", nillable = false)
public List<JNDIProperty> getJndiProperties() { public List<JNDIProperty> getJndiProperties() {
return jndiProperties; return jndiProperties;

@ -37,4 +37,6 @@ public interface DeviceTypeDAO {
Integer getDeviceTypeIdByDeviceTypeName(String type) throws DeviceManagementDAOException; Integer getDeviceTypeIdByDeviceTypeName(String type) throws DeviceManagementDAOException;
void removeDeviceType(DeviceType deviceType) throws DeviceManagementDAOException;
} }

@ -124,6 +124,11 @@ public class DeviceTypeDAOImpl implements DeviceTypeDAO {
return deviceTypeId; return deviceTypeId;
} }
@Override
public void removeDeviceType(DeviceType deviceType) throws DeviceManagementDAOException {
}
private Connection getConnection() throws DeviceManagementDAOException { private Connection getConnection() throws DeviceManagementDAOException {
try { try {
return dataSource.getConnection(); return dataSource.getConnection();

@ -63,7 +63,8 @@ public final class DeviceManagementDAOUtil {
} }
/** /**
* Get id of the current tenant * Get id of the current tenant.
*
* @return tenant id * @return tenant id
* @throws DeviceManagementDAOException if an error is observed when getting tenant id * @throws DeviceManagementDAOException if an error is observed when getting tenant id
*/ */
@ -94,7 +95,7 @@ public final class DeviceManagementDAOUtil {
return (DataSource) InitialContext.doLookup(dataSourceName); return (DataSource) InitialContext.doLookup(dataSourceName);
} }
final InitialContext context = new InitialContext(jndiProperties); final InitialContext context = new InitialContext(jndiProperties);
return (DataSource) context.doLookup(dataSourceName); return (DataSource) context.lookup(dataSourceName);
} catch (Exception e) { } catch (Exception e) {
throw new RuntimeException("Error in looking up data source: " + e.getMessage(), e); throw new RuntimeException("Error in looking up data source: " + e.getMessage(), e);
} }

@ -23,6 +23,7 @@ import org.osgi.framework.BundleContext;
import org.osgi.service.component.ComponentContext; import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagerService; import org.wso2.carbon.device.mgt.common.spi.DeviceManagerService;
import org.wso2.carbon.device.mgt.core.DeviceManagementConstants;
import org.wso2.carbon.device.mgt.core.DeviceManagementRepository; import org.wso2.carbon.device.mgt.core.DeviceManagementRepository;
import org.wso2.carbon.device.mgt.core.DeviceManager; import org.wso2.carbon.device.mgt.core.DeviceManager;
import org.wso2.carbon.device.mgt.core.DeviceManagerImpl; import org.wso2.carbon.device.mgt.core.DeviceManagerImpl;
@ -49,14 +50,17 @@ import org.wso2.carbon.user.core.service.RealmService;
* bind="setDeviceManagerService" * bind="setDeviceManagerService"
* unbind="unsetDeviceManagerService" * unbind="unsetDeviceManagerService"
*/ */
@SuppressWarnings("unused")
public class DeviceManagementServiceComponent { public class DeviceManagementServiceComponent {
public static final String SETUP_OPTION = "setup";
private static Log log = LogFactory.getLog(DeviceManagementServiceComponent.class); private static Log log = LogFactory.getLog(DeviceManagementServiceComponent.class);
private DeviceManagementRepository pluginRepository = new DeviceManagementRepository(); private DeviceManagementRepository pluginRepository = new DeviceManagementRepository();
protected void activate(ComponentContext componentContext) { protected void activate(ComponentContext componentContext) {
try { try {
if (log.isDebugEnabled()) {
log.debug("Initializing device management core bundle");
}
/* Initializing Device Management Configuration */ /* Initializing Device Management Configuration */
DeviceConfigurationManager.getInstance().initConfig(); DeviceConfigurationManager.getInstance().initConfig();
DeviceManagementConfig config = DeviceConfigurationManager.getInstance().getDeviceManagementConfig(); DeviceManagementConfig config = DeviceConfigurationManager.getInstance().getDeviceManagementConfig();
@ -68,19 +72,24 @@ public class DeviceManagementServiceComponent {
DeviceManagementDataHolder.getInstance().setDeviceManager(deviceManager); DeviceManagementDataHolder.getInstance().setDeviceManager(deviceManager);
/* If -Dsetup option enabled then create device management database schema */ /* If -Dsetup option enabled then create device management database schema */
String setupOption = System.getProperty(SETUP_OPTION); String setupOption = System.getProperty(DeviceManagementConstants.Common.PROPERTY_SETUP);
if (setupOption != null) { if (setupOption != null) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("-Dsetup is enabled. Device management repository schema initialization is about " + log.debug("-Dsetup is enabled. Device management repository schema initialization is about " +
"to begin"); "to begin");
} }
setupDeviceManagementSchema(dsConfig); this.setupDeviceManagementSchema(dsConfig);
} }
if (log.isDebugEnabled()) {
log.debug("Registering OSGi service DeviceManagementService");
}
BundleContext bundleContext = componentContext.getBundleContext(); BundleContext bundleContext = componentContext.getBundleContext();
bundleContext.registerService(DeviceManagementService.class.getName(), bundleContext.registerService(DeviceManagementService.class.getName(),
new DeviceManagementService(), null); new DeviceManagementService(), null);
if (log.isDebugEnabled()) {
log.debug("Device management core bundle has been successfully initialized");
}
} catch (Throwable e) { } catch (Throwable e) {
String msg = "Error occurred while initializing device management core bundle"; String msg = "Error occurred while initializing device management core bundle";
log.error(msg, e); log.error(msg, e);
@ -91,38 +100,43 @@ public class DeviceManagementServiceComponent {
DeviceManagementSchemaInitializer initializer = new DeviceManagementSchemaInitializer(config); DeviceManagementSchemaInitializer initializer = new DeviceManagementSchemaInitializer(config);
log.info("Initializing device management repository database schema"); log.info("Initializing device management repository database schema");
// catch generic exception. If any error occurs wrap and throw DeviceManagementException
try { try {
initializer.createRegistryDatabase(); initializer.createRegistryDatabase();
} catch (Exception e) { } catch (Exception e) {
throw new DeviceManagementException("Error occurred while initializing Device Management " + throw new DeviceManagementException("Error occurred while initializing Device Management " +
"database schema", e); "database schema", e);
} }
if (log.isDebugEnabled()) {
log.debug("Device management metadata repository schema has been successfully initialized");
}
} }
/** /**
* Sets Device Manager services * Sets Device Manager service.
* @param deviceManager An instance of DeviceManagerService * @param deviceManagerService An instance of DeviceManagerService
*/ */
protected void setDeviceManagerService(DeviceManagerService deviceManager) { protected void setDeviceManagerService(DeviceManagerService deviceManagerService) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Setting Device Management Service"); log.debug("Setting Device Management Service Provider : '" +
deviceManagerService.getProviderType() + "'");
} }
this.getPluginRepository().addDeviceManagementProvider(deviceManager); this.getPluginRepository().addDeviceManagementProvider(deviceManagerService);
} }
/** /**
* Unsets Device Management services * Unsets Device Management service.
* @param deviceManager An instance of DeviceManagerService * @param deviceManagerService An Instance of DeviceManagerService
*/ */
protected void unsetDeviceManagerService(DeviceManagerService deviceManager) { protected void unsetDeviceManagerService(DeviceManagerService deviceManagerService) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Unsetting Device Management Service"); log.debug("Unsetting Device Management Service Provider : '" +
deviceManagerService.getProviderType() + "'");
} }
this.getPluginRepository().removeDeviceManagementProvider(deviceManagerService);
} }
/** /**
* Sets Realm Service * Sets Realm Service.
* @param realmService An instance of RealmService * @param realmService An instance of RealmService
*/ */
protected void setRealmService(RealmService realmService) { protected void setRealmService(RealmService realmService) {
@ -133,7 +147,7 @@ public class DeviceManagementServiceComponent {
} }
/** /**
* Unsets Realm Service * Unsets Realm Service.
* @param realmService An instance of RealmService * @param realmService An instance of RealmService
*/ */
protected void unsetRealmService(RealmService realmService) { protected void unsetRealmService(RealmService realmService) {

@ -87,24 +87,47 @@ public final class DeviceManagerUtil {
/** /**
* Adds a new device type to the database if it does not exists. * Adds a new device type to the database if it does not exists.
* *
* @param deviceTypeName device type * @param deviceType device type
* @return status of the operation * @return status of the operation
*/ */
public static boolean registerDeviceType(String deviceTypeName) throws DeviceManagementException{ public static boolean registerDeviceType(String deviceType) throws DeviceManagementException {
boolean status = false; boolean status;
try { try {
DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO(); DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
Integer deviceTypeId = deviceTypeDAO.getDeviceTypeIdByDeviceTypeName(deviceTypeName); Integer deviceTypeId = deviceTypeDAO.getDeviceTypeIdByDeviceTypeName(deviceType);
if(deviceTypeId == null){ if (deviceTypeId == null) {
DeviceType deviceType = new DeviceType(); DeviceType dt = new DeviceType();
deviceType.setName(deviceTypeName); dt.setName(deviceType);
deviceTypeDAO.addDeviceType(deviceType); deviceTypeDAO.addDeviceType(dt);
} }
status = true; status = true;
} catch (DeviceManagementDAOException e) { } catch (DeviceManagementDAOException e) {
String msg = "Error occurred while registering the device type " + deviceTypeName; String msg = "Error occurred while registering the device type " + deviceType;
throw new DeviceManagementException(msg, e); throw new DeviceManagementException(msg, e);
} }
return status; return status;
} }
/**
* Unregisters an existing device type from the device management metadata repository.
*
* @param deviceType device type
* @return status of the operation
*/
public static boolean unregisterDeviceType(String deviceType) throws DeviceManagementException {
try {
DeviceTypeDAO deviceTypeDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
Integer deviceTypeId = deviceTypeDAO.getDeviceTypeIdByDeviceTypeName(deviceType);
if (deviceTypeId == null) {
DeviceType dt = new DeviceType();
dt.setName(deviceType);
deviceTypeDAO.removeDeviceType(dt);
}
return true;
} catch (DeviceManagementDAOException e) {
String msg = "Error occurred while registering the device type " + deviceType;
throw new DeviceManagementException(msg, e);
}
}
} }

@ -0,0 +1,95 @@
/**
* Copyright (c) 2015, 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.core;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import org.wso2.carbon.device.mgt.core.config.DeviceManagementConfig;
import org.xml.sax.SAXException;
import javax.xml.XMLConstants;
import javax.xml.bind.JAXBContext;
import javax.xml.bind.JAXBException;
import javax.xml.bind.Unmarshaller;
import javax.xml.validation.Schema;
import javax.xml.validation.SchemaFactory;
import java.io.File;
public class DeviceManagementConfigTests {
private static final Log log = LogFactory.getLog(DeviceManagementConfigTests.class);
private static final String MALFORMED_TEST_CONFIG_LOCATION_NO_MGT_REPOSITORY =
"./src/test/resources/config/malformed-cdm-config-no-mgt-repo.xml";
private static final String MALFORMED_TEST_CONFIG_LOCATION_NO_DS_CONFIG =
"./src/test/resources/config/malformed-cdm-config-no-ds-config.xml";
private static final String MALFORMED_TEST_CONFIG_LOCATION_NO_JNDI_CONFIG =
"./src/test/resources/config/malformed-cdm-config-no-jndi-config.xml";
private static final String TEST_CONFIG_SCHEMA_LOCATION =
"./src/test/resources/config/schema/DeviceManagementConfigSchema.xsd";
private Schema schema;
@BeforeClass
private void initSchema() {
File deviceManagementSchemaConfig = new File(DeviceManagementConfigTests.TEST_CONFIG_SCHEMA_LOCATION);
SchemaFactory factory = SchemaFactory.newInstance(XMLConstants.W3C_XML_SCHEMA_NS_URI);
try {
schema = factory.newSchema(deviceManagementSchemaConfig);
} catch (SAXException e) {
Assert.fail("Invalid schema found", e);
}
}
@Test()
public void testMandateManagementRepositoryElement() {
File malformedConfig =
new File(DeviceManagementConfigTests.MALFORMED_TEST_CONFIG_LOCATION_NO_MGT_REPOSITORY);
this.validateMalformedConfig(malformedConfig);
}
@Test
public void testMandateDataSourceConfigurationElement() {
File malformedConfig = new File(DeviceManagementConfigTests.MALFORMED_TEST_CONFIG_LOCATION_NO_DS_CONFIG);
this.validateMalformedConfig(malformedConfig);
}
@Test
public void testMandateJndiLookupDefinitionElement() {
File malformedConfig = new File(DeviceManagementConfigTests.MALFORMED_TEST_CONFIG_LOCATION_NO_JNDI_CONFIG);
this.validateMalformedConfig(malformedConfig);
}
private void validateMalformedConfig(File malformedConfig) {
try {
JAXBContext ctx = JAXBContext.newInstance(DeviceManagementConfig.class);
Unmarshaller um = ctx.createUnmarshaller();
um.setSchema(this.getSchema());
um.unmarshal(malformedConfig);
Assert.assertTrue(false);
} catch (JAXBException e) {
log.error("Error occurred while unmarsharlling device management config", e);
Assert.assertTrue(true);
}
}
private Schema getSchema() {
return schema;
}
}

@ -0,0 +1,58 @@
/**
* Copyright (c) 2015, 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.core;
import org.testng.Assert;
import org.testng.annotations.BeforeClass;
import org.testng.annotations.Test;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagerService;
public class DeviceManagementRepositoryTests {
private DeviceManagementRepository repository;
@BeforeClass
public void initRepository() {
this.repository = new DeviceManagementRepository();
}
@Test
public void testAddDeviceManagementService() {
DeviceManagerService sourceProvider = new TestDeviceManagerService();
this.getRepository().addDeviceManagementProvider(sourceProvider);
DeviceManagerService targetProvider =
this.getRepository().getDeviceManagementProvider(TestDeviceManagerService.DEVICE_TYPE_TEST);
Assert.assertEquals(targetProvider.getProviderType(), sourceProvider.getProviderType());
}
@Test(dependsOnMethods = "testAddDeviceManagementService")
public void testRemoveDeviceManagementService() {
DeviceManagerService sourceProvider = new TestDeviceManagerService();
this.getRepository().removeDeviceManagementProvider(sourceProvider);
DeviceManagerService targetProvider =
this.getRepository().getDeviceManagementProvider(TestDeviceManagerService.DEVICE_TYPE_TEST);
Assert.assertNull(targetProvider);
}
private DeviceManagementRepository getRepository() {
return repository;
}
}

@ -0,0 +1,90 @@
/**
* Copyright (c) 2012, 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.core;
import org.wso2.carbon.device.mgt.common.Device;
import org.wso2.carbon.device.mgt.common.DeviceIdentifier;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.OperationManager;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagerService;
import java.util.List;
public class TestDeviceManagerService implements DeviceManagerService {
public static final String DEVICE_TYPE_TEST = "Test";
@Override
public String getProviderType() {
return TestDeviceManagerService.DEVICE_TYPE_TEST;
}
@Override
public boolean enrollDevice(Device device) throws DeviceManagementException {
return false;
}
@Override
public boolean modifyEnrollment(Device device) throws DeviceManagementException {
return false;
}
@Override
public boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
return false;
}
@Override
public boolean isEnrolled(DeviceIdentifier deviceId) throws DeviceManagementException {
return false;
}
@Override
public boolean isActive(DeviceIdentifier deviceId) throws DeviceManagementException {
return false;
}
@Override
public boolean setActive(DeviceIdentifier deviceId, boolean status) throws DeviceManagementException {
return false;
}
@Override
public List<Device> getAllDevices() throws DeviceManagementException {
return null;
}
@Override
public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
return null;
}
@Override
public boolean updateDeviceInfo(Device device) throws DeviceManagementException {
return false;
}
@Override
public boolean setOwnership(DeviceIdentifier deviceId, String ownershipType) throws DeviceManagementException {
return false;
}
@Override
public OperationManager getOperationManager() throws DeviceManagementException {
return null;
}
}

@ -0,0 +1,54 @@
/**
* Copyright (c) 2012, 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.core;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
public class TestUtils {
private static final Log log = LogFactory.getLog(TestUtils.class);
public static void cleanupResources(Connection conn, Statement stmt, ResultSet rs) {
if (rs != null) {
try {
rs.close();
} catch (SQLException e) {
log.warn("Error occurred while closing result set", e);
}
}
if (stmt != null) {
try {
stmt.close();
} catch (SQLException e) {
log.warn("Error occurred while closing prepared statement", e);
}
}
if (conn != null) {
try {
conn.close();
} catch (SQLException e) {
log.warn("Error occurred while closing database connection", e);
}
}
}
}

@ -25,6 +25,7 @@ import org.testng.annotations.Parameters;
import org.testng.annotations.Test; import org.testng.annotations.Test;
import org.w3c.dom.Document; import org.w3c.dom.Document;
import org.wso2.carbon.device.mgt.common.DeviceManagementException; import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.core.TestUtils;
import org.wso2.carbon.device.mgt.core.common.DBTypes; import org.wso2.carbon.device.mgt.core.common.DBTypes;
import org.wso2.carbon.device.mgt.core.common.TestDBConfiguration; import org.wso2.carbon.device.mgt.core.common.TestDBConfiguration;
import org.wso2.carbon.device.mgt.core.common.TestDBConfigurations; import org.wso2.carbon.device.mgt.core.common.TestDBConfigurations;
@ -40,42 +41,33 @@ import javax.xml.bind.Unmarshaller;
import java.io.File; import java.io.File;
import java.sql.*; import java.sql.*;
import java.util.Date; import java.util.Date;
import java.util.Iterator;
public class DeviceMgtDAOTestSuite { public class DeviceManagementDAOTests {
private TestDBConfiguration testDBConfiguration;
private DeviceType devType = new DeviceType();
private Connection conn = null;
private Statement stmt = null;
@BeforeClass @BeforeClass
@Parameters("dbType") @Parameters("dbType")
public void setUpDB(String dbTypeStr) throws Exception { public void setUpDB(String dbTypeStr) throws Exception {
DBTypes dbType = DBTypes.valueOf(dbTypeStr); DBTypes dbType = DBTypes.valueOf(dbTypeStr);
testDBConfiguration = getTestDBConfiguration(dbType); TestDBConfiguration dbConfig = getTestDBConfiguration(dbType);
switch (dbType) { switch (dbType) {
case H2: case H2:
createH2DB(testDBConfiguration); createH2DB(dbConfig);
BasicDataSource testDataSource = new BasicDataSource(); BasicDataSource testDataSource = new BasicDataSource();
testDataSource.setDriverClassName(testDBConfiguration.getDriverClass()); testDataSource.setDriverClassName(dbConfig.getDriverClass());
testDataSource.setUrl(testDBConfiguration.getConnectionUrl()); testDataSource.setUrl(dbConfig.getConnectionUrl());
testDataSource.setUsername(testDBConfiguration.getUserName()); testDataSource.setUsername(dbConfig.getUserName());
testDataSource.setPassword(testDBConfiguration.getPwd()); testDataSource.setPassword(dbConfig.getPwd());
DeviceManagementDAOFactory.init(testDataSource); DeviceManagementDAOFactory.init(testDataSource);
default: default:
} }
} }
private TestDBConfiguration getTestDBConfiguration(DBTypes dbType) throws DeviceManagementDAOException, private TestDBConfiguration getTestDBConfiguration(DBTypes dbType) throws DeviceManagementDAOException,
DeviceManagementException { DeviceManagementException {
File deviceMgtConfig = new File("src/test/resources/testdbconfig.xml"); File deviceMgtConfig = new File("src/test/resources/testdbconfig.xml");
Document doc = null; Document doc;
testDBConfiguration = null; TestDBConfigurations dbConfigs;
TestDBConfigurations testDBConfigurations = null;
doc = DeviceManagerUtil.convertToDocument(deviceMgtConfig); doc = DeviceManagerUtil.convertToDocument(deviceMgtConfig);
JAXBContext testDBContext = null; JAXBContext testDBContext = null;
@ -83,92 +75,100 @@ public class DeviceMgtDAOTestSuite {
try { try {
testDBContext = JAXBContext.newInstance(TestDBConfigurations.class); testDBContext = JAXBContext.newInstance(TestDBConfigurations.class);
Unmarshaller unmarshaller = testDBContext.createUnmarshaller(); Unmarshaller unmarshaller = testDBContext.createUnmarshaller();
testDBConfigurations = (TestDBConfigurations) unmarshaller.unmarshal(doc); dbConfigs = (TestDBConfigurations) unmarshaller.unmarshal(doc);
} catch (JAXBException e) { } catch (JAXBException e) {
throw new DeviceManagementDAOException("Error parsing test db configurations", e); throw new DeviceManagementDAOException("Error parsing test db configurations", e);
} }
Iterator<TestDBConfiguration> itrDBConfigs = testDBConfigurations.getDbTypesList().iterator(); for (TestDBConfiguration config : dbConfigs.getDbTypesList()) {
while (itrDBConfigs.hasNext()) { if (config.getDbType().equals(dbType.toString())) {
testDBConfiguration = itrDBConfigs.next(); return config;
if (testDBConfiguration.getDbType().equals(dbType.toString())) {
break;
} }
} }
return null;
return testDBConfiguration;
} }
private void createH2DB(TestDBConfiguration testDBConf) throws Exception { private void createH2DB(TestDBConfiguration testDBConf) throws Exception {
Connection conn = null;
Class.forName(testDBConf.getDriverClass()); Statement stmt = null;
conn = DriverManager.getConnection(testDBConf.getConnectionUrl()); try {
stmt = conn.createStatement(); Class.forName(testDBConf.getDriverClass());
stmt.executeUpdate("RUNSCRIPT FROM './src/test/resources/sql/CreateH2TestDB.sql'"); conn = DriverManager.getConnection(testDBConf.getConnectionUrl());
stmt.close(); stmt = conn.createStatement();
conn.close(); stmt.executeUpdate("RUNSCRIPT FROM './src/test/resources/sql/CreateH2TestDB.sql'");
} finally {
TestUtils.cleanupResources(conn, stmt, null);
}
} }
@Test @Test
public void addDeviceTypeTest() throws DeviceManagementDAOException, DeviceManagementException { public void addDeviceTypeTest() throws DeviceManagementDAOException, DeviceManagementException {
DeviceTypeDAO deviceTypeMgtDAO = DeviceManagementDAOFactory.getDeviceTypeDAO(); DeviceTypeDAO deviceTypeMgtDAO = DeviceManagementDAOFactory.getDeviceTypeDAO();
devType.setName("IOS"); DeviceType deviceType = new DeviceType();
deviceType.setName("IOS");
deviceTypeMgtDAO.addDeviceType(devType); deviceTypeMgtDAO.addDeviceType(deviceType);
Long deviceTypeId = null; Long deviceTypeId = null;
Connection conn = null;
Statement stmt = null;
try { try {
conn = DeviceManagementDAOFactory.getDataSource().getConnection(); conn = DeviceManagementDAOFactory.getDataSource().getConnection();
stmt = conn.createStatement(); stmt = conn.createStatement();
ResultSet resultSet = stmt.executeQuery("SELECT ID,NAME from DM_DEVICE_TYPE DType where DType.NAME='IOS'"); ResultSet resultSet =
stmt.executeQuery("SELECT ID,NAME from DM_DEVICE_TYPE DType where DType.NAME='IOS'");
while (resultSet.next()) { while (resultSet.next()) {
deviceTypeId = resultSet.getLong(1); deviceTypeId = resultSet.getLong(1);
} }
conn.close();
} catch (SQLException sqlEx) { } catch (SQLException sqlEx) {
throw new DeviceManagementDAOException("error in fetch device type by name IOS", sqlEx); throw new DeviceManagementDAOException("error in fetch device type by name IOS", sqlEx);
} finally {
TestUtils.cleanupResources(conn, stmt, null);
} }
Assert.assertNotNull(deviceTypeId, "Device Type Id is null"); Assert.assertNotNull(deviceTypeId, "Device Type Id is null");
devType.setId(deviceTypeId); deviceType.setId(deviceTypeId);
} }
@Test(dependsOnMethods = { "addDeviceTypeTest" }) @Test(dependsOnMethods = {"addDeviceTypeTest"})
public void addDeviceTest() throws DeviceManagementDAOException, DeviceManagementException { public void addDeviceTest() throws DeviceManagementDAOException, DeviceManagementException {
DeviceDAO deviceMgtDAO = DeviceManagementDAOFactory.getDeviceDAO(); DeviceDAO deviceMgtDAO = DeviceManagementDAOFactory.getDeviceDAO();
Device device = new Device(); Device device = new Device();
device.setDateOfEnrollment(new Date().getTime()); device.setDateOfEnrollment(new Date().getTime());
device.setDateOfLastUpdate(new Date().getTime()); device.setDateOfLastUpdate(new Date().getTime());
device.setDescription("test description"); device.setDescription("test description");
device.setStatus(Status.ACTIVE); device.setStatus(Status.ACTIVE);
device.setDeviceIdentificationId("111"); device.setDeviceIdentificationId("111");
device.setDeviceType(devType.getId().intValue());
DeviceType deviceType = new DeviceType();
deviceType.setId(Long.parseLong("1"));
device.setDeviceType(deviceType.getId().intValue());
device.setOwnerShip(OwnerShip.BYOD.toString()); device.setOwnerShip(OwnerShip.BYOD.toString());
device.setOwnerId("111"); device.setOwnerId("111");
device.setTenantId(-1234); device.setTenantId(-1234);
deviceMgtDAO.addDevice(device); deviceMgtDAO.addDevice(device);
Long deviceId = null; Long deviceId = null;
Connection conn = null;
PreparedStatement stmt = null;
ResultSet rs = null;
try { try {
conn = DeviceManagementDAOFactory.getDataSource().getConnection(); conn = DeviceManagementDAOFactory.getDataSource().getConnection();
stmt = conn.createStatement(); stmt = conn.prepareStatement("SELECT ID from DM_DEVICE DEVICE where DEVICE.DEVICE_IDENTIFICATION='111'");
ResultSet resultSet = stmt rs = stmt.executeQuery();
.executeQuery("SELECT ID from DM_DEVICE DEVICE where DEVICE.DEVICE_IDENTIFICATION='111'");
while (resultSet.next()) { while (rs.next()) {
deviceId = resultSet.getLong(1); deviceId = rs.getLong(1);
} }
conn.close(); } catch (SQLException e) {
} catch (SQLException sqlEx) { throw new DeviceManagementDAOException("error in fetch device by device identification id", e);
throw new DeviceManagementDAOException("error in fetch device by device identification id", sqlEx); } finally {
TestUtils.cleanupResources(conn, stmt, rs);
} }
Assert.assertNotNull(deviceId, "Device Id is null"); Assert.assertNotNull(deviceId, "Device Id is null");

@ -0,0 +1,26 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--
~ 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.
~ 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.
-->
<DeviceMgtConfiguration>
<ManagementRepository>
<MalformedDataSourceConfiguration>
<JndiLookupDefinition>
<Name>jdbc/DEVICE_MGT_DS</Name>
</JndiLookupDefinition>
</MalformedDataSourceConfiguration>
</ManagementRepository>
</DeviceMgtConfiguration>

@ -0,0 +1,26 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--
~ 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.
~ 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.
-->
<DeviceMgtConfiguration>
<ManagementRepository>
<DataSourceConfiguration>
<MalformedJndiLookupDefinition>
<Name>jdbc/DEVICE_MGT_DS</Name>
</MalformedJndiLookupDefinition>
</DataSourceConfiguration>
</ManagementRepository>
</DeviceMgtConfiguration>

@ -0,0 +1,26 @@
<?xml version="1.0" encoding="ISO-8859-1"?>
<!--
~ 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.
~ 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.
-->
<DeviceMgtConfiguration>
<MalformedManagementRepository>
<DataSourceConfiguration>
<JndiLookupDefinition>
<Name>jdbc/DEVICE_MGT_DS</Name>
</JndiLookupDefinition>
</DataSourceConfiguration>
</MalformedManagementRepository>
</DeviceMgtConfiguration>

@ -0,0 +1,45 @@
<?xml version="1.0" encoding="UTF-8"?>
<!--
~ 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.
~ 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.
-->
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" elementFormDefault="qualified"
attributeFormDefault="unqualified">
<xs:element name="DeviceMgtConfiguration">
<xs:complexType>
<xs:sequence>
<xs:element name="ManagementRepository" minOccurs="1" maxOccurs="1" type="DataSourceConfigurationType"/>
</xs:sequence>
</xs:complexType>
</xs:element>
<xs:complexType name="JndiLookupDefinitionType">
<xs:sequence>
<xs:element name="Name" type="xs:string" minOccurs="1" maxOccurs="1"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="DataSourceConfigurationType">
<xs:sequence>
<xs:element name="JndiLookupDefinition" minOccurs="1" maxOccurs="1"
type="JndiLookupDefinitionType"/>
</xs:sequence>
</xs:complexType>
<xs:complexType name="ManagementRepositoryType">
<xs:sequence>
<xs:element name="DataSourceConfiguration" minOccurs="1" maxOccurs="1"
type="DataSourceConfigurationType"/>
</xs:sequence>
</xs:complexType>
</xs:schema>

@ -21,8 +21,9 @@
<test name="DAO Unit Tests" preserve-order="true"> <test name="DAO Unit Tests" preserve-order="true">
<parameter name="dbType" value="H2"/> <parameter name="dbType" value="H2"/>
<classes> <classes>
<class name="org.wso2.carbon.device.mgt.core.dao.DeviceManagementDAOTests"/>
<class name="org.wso2.carbon.device.mgt.core.dao.DeviceMgtDAOTestSuite"/> <class name="org.wso2.carbon.device.mgt.core.DeviceManagementRepositoryTests"/>
<class name="org.wso2.carbon.device.mgt.core.DeviceManagementConfigTests"/>
</classes> </classes>
</test> </test>
</suite> </suite>

@ -52,7 +52,7 @@
<Bundle-Name>${project.artifactId}</Bundle-Name> <Bundle-Name>${project.artifactId}</Bundle-Name>
<Bundle-Version>${project.version}</Bundle-Version> <Bundle-Version>${project.version}</Bundle-Version>
<Bundle-Description>Device Management Mobile Impl Bundle</Bundle-Description> <Bundle-Description>Device Management Mobile Impl Bundle</Bundle-Description>
<Bundle-Activator>org.wso2.carbon.device.mgt.mobile.internal.MobileDeviceManagementBundleActivator</Bundle-Activator> <!--<Bundle-Activator>org.wso2.carbon.device.mgt.mobile.internal.MobileDeviceManagementBundleActivator</Bundle-Activator>-->
<Private-Package>org.wso2.carbon.device.mgt.mobile.internal</Private-Package> <Private-Package>org.wso2.carbon.device.mgt.mobile.internal</Private-Package>
<Import-Package> <Import-Package>
org.osgi.framework, org.osgi.framework,

@ -22,15 +22,15 @@ import java.util.List;
public abstract class AbstractMobileOperationManager implements OperationManager { public abstract class AbstractMobileOperationManager implements OperationManager {
@Override @Override
public List<Operation> getOperations(DeviceIdentifier deviceIdentifier) public List<Operation> getOperations(DeviceIdentifier deviceIdentifier) throws OperationManagementException {
throws OperationManagementException { return null;
return null; }
}
@Override
public boolean addOperation(Operation operation,
List<DeviceIdentifier> devices) throws OperationManagementException {
return true;
}
@Override
public boolean addOperation(Operation operation, List<DeviceIdentifier> devices) throws
OperationManagementException {
return true;
}
} }

@ -18,6 +18,7 @@ package org.wso2.carbon.device.mgt.mobile.dao;
import org.apache.commons.logging.Log; import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory; import org.apache.commons.logging.LogFactory;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.mobile.DataSourceListener; import org.wso2.carbon.device.mgt.mobile.DataSourceListener;
import org.wso2.carbon.device.mgt.mobile.config.datasource.MobileDataSourceConfig; import org.wso2.carbon.device.mgt.mobile.config.datasource.MobileDataSourceConfig;
import org.wso2.carbon.device.mgt.mobile.dao.impl.*; import org.wso2.carbon.device.mgt.mobile.dao.impl.*;
@ -31,66 +32,68 @@ import javax.sql.DataSource;
*/ */
public class MobileDeviceManagementDAOFactory implements DataSourceListener { public class MobileDeviceManagementDAOFactory implements DataSourceListener {
private static DataSource dataSource; private static DataSource dataSource;
private static MobileDataSourceConfig mobileDataSourceConfig; private static MobileDataSourceConfig mobileDataSourceConfig;
private static final Log log = LogFactory.getLog(MobileDeviceManagementDAOFactory.class); private static final Log log = LogFactory.getLog(MobileDeviceManagementDAOFactory.class);
public MobileDeviceManagementDAOFactory() { public MobileDeviceManagementDAOFactory() {
} }
public void init(){ public void init() throws DeviceManagementException {
dataSource = MobileDeviceManagementDAOUtil.resolveDataSource(mobileDataSourceConfig); dataSource = MobileDeviceManagementDAOUtil.resolveDataSource(mobileDataSourceConfig);
if(dataSource!=null){ if (dataSource != null) {
MobileDeviceManagementDAOUtil.createDataSource(dataSource); MobileDeviceManagementDAOUtil.createDataSource(dataSource);
}else{ } else {
MobileDeviceManagementBundleActivator.registerDataSourceListener(this); MobileDeviceManagementBundleActivator.registerDataSourceListener(this);
} }
} }
public static MobileDeviceDAO getMobileDeviceDAO() { public static MobileDeviceDAO getMobileDeviceDAO() {
return new MobileDeviceDAOImpl(dataSource); return new MobileDeviceDAOImpl(dataSource);
} }
public static OperationDAO getOperationDAO(){ public static OperationDAO getOperationDAO() {
return new OperationDAOImpl(dataSource); return new OperationDAOImpl(dataSource);
} }
public static OperationPropertyDAO geOperationPropertyDAO(){ public static OperationPropertyDAO geOperationPropertyDAO() {
return new OperationPropertyDAOImpl(dataSource); return new OperationPropertyDAOImpl(dataSource);
} }
public static DeviceOperationDAO getDeviceOperationDAO(){ public static DeviceOperationDAO getDeviceOperationDAO() {
return new DeviceOperationDAOImpl(dataSource); return new DeviceOperationDAOImpl(dataSource);
} }
public static FeatureDAO getFeatureDAO(){ public static FeatureDAO getFeatureDAO() {
return new FeatureDAOImpl(dataSource); return new FeatureDAOImpl(dataSource);
} }
public static FeaturePropertyDAO getFeaturePropertyDAO(){ public static FeaturePropertyDAO getFeaturePropertyDAO() {
return new FeaturePropertyDAOImpl(dataSource); return new FeaturePropertyDAOImpl(dataSource);
} }
public static MobileDataSourceConfig getMobileDeviceManagementConfig() { public static MobileDataSourceConfig getMobileDeviceManagementConfig() {
return mobileDataSourceConfig; return mobileDataSourceConfig;
} }
public static void setMobileDataSourceConfig( public static void setMobileDataSourceConfig(
MobileDataSourceConfig mobileDataSourceConfig) { MobileDataSourceConfig mobileDataSourceConfig) {
MobileDeviceManagementDAOFactory.mobileDataSourceConfig = MobileDeviceManagementDAOFactory.mobileDataSourceConfig =
mobileDataSourceConfig; mobileDataSourceConfig;
} }
public static DataSource getDataSource() { public static DataSource getDataSource() {
return dataSource; return dataSource;
} }
@Override @Override
public void notifyObserver() { public void notifyObserver() {
dataSource = MobileDeviceManagementDAOUtil.resolveDataSource(mobileDataSourceConfig); try {
if(dataSource!=null){ dataSource = MobileDeviceManagementDAOUtil.resolveDataSource(mobileDataSourceConfig);
MobileDeviceManagementDAOUtil.createDataSource(dataSource); MobileDeviceManagementDAOUtil.createDataSource(dataSource);
} } catch (DeviceManagementException e) {
} log.error("Error occurred while resolving mobile device management metadata repository data source", e);
}
}
} }

@ -37,136 +37,119 @@ import java.util.List;
*/ */
public class MobileDeviceManagementDAOUtil { public class MobileDeviceManagementDAOUtil {
private static final Log log = LogFactory.getLog(MobileDeviceManagementDAOUtil.class); private static final Log log = LogFactory.getLog(MobileDeviceManagementDAOUtil.class);
/** /**
* Resolve data source from the data source definition. * Resolve data source from the data source definition.
* *
* @param config Mobile data source configuration * @param config Mobile data source configuration
* @return data source resolved from the data source definition * @return data source resolved from the data source definition
*/ */
public static DataSource resolveDataSource(MobileDataSourceConfig config) { public static DataSource resolveDataSource(MobileDataSourceConfig config) throws DeviceManagementException {
DataSource dataSource = null; DataSource dataSource = null;
if (config == null) { if (config == null) {
throw new RuntimeException("Device Management Repository data source configuration " + throw new RuntimeException("Device Management Repository data source configuration " +
"is null and thus, is not initialized"); "is null and thus, is not initialized");
} }
JNDILookupDefinition jndiConfig = config.getJndiLookupDefintion(); JNDILookupDefinition jndiConfig = config.getJndiLookupDefintion();
if (jndiConfig != null) { if (jndiConfig != null) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug("Initializing Device Management Repository data source using the JNDI " + log.debug("Initializing Device Management Repository data source using the JNDI " +
"Lookup Definition"); "Lookup Definition");
} }
List<JNDILookupDefinition.JNDIProperty> jndiPropertyList = List<JNDILookupDefinition.JNDIProperty> jndiPropertyList =
jndiConfig.getJndiProperties(); jndiConfig.getJndiProperties();
if (jndiPropertyList != null) { if (jndiPropertyList != null) {
Hashtable<Object, Object> jndiProperties = new Hashtable<Object, Object>(); Hashtable<Object, Object> jndiProperties = new Hashtable<Object, Object>();
for (JNDILookupDefinition.JNDIProperty prop : jndiPropertyList) { for (JNDILookupDefinition.JNDIProperty prop : jndiPropertyList) {
jndiProperties.put(prop.getName(), prop.getValue()); jndiProperties.put(prop.getName(), prop.getValue());
} }
try { dataSource =
dataSource = MobileDeviceManagementDAOUtil.lookupDataSource( MobileDeviceManagementDAOUtil.lookupDataSource(jndiConfig.getJndiName(), jndiProperties);
jndiConfig.getJndiName(), jndiProperties); } else {
} catch (DeviceManagementException e) { dataSource = MobileDeviceManagementDAOUtil.lookupDataSource(jndiConfig.getJndiName(), null);
if (log.isDebugEnabled()) { }
log.debug("Error in looking up data source: " + e.getMessage()); }
} return dataSource;
log.error(e); }
}
} else {
try {
dataSource = MobileDeviceManagementDAOUtil.lookupDataSource(
jndiConfig.getJndiName(), null);
} catch (DeviceManagementException e) {
if (log.isDebugEnabled()) {
log.debug("Error in looking up data source: " + e.getMessage());
}
log.error(e);
}
}
}
return dataSource;
}
public static DataSource lookupDataSource(String dataSourceName, public static DataSource lookupDataSource(String dataSourceName,
final Hashtable<Object, Object> jndiProperties) final Hashtable<Object, Object> jndiProperties)
throws DeviceManagementException { throws DeviceManagementException {
try { try {
if (jndiProperties == null || jndiProperties.isEmpty()) { if (jndiProperties == null || jndiProperties.isEmpty()) {
return (DataSource) InitialContext.doLookup(dataSourceName); return (DataSource) InitialContext.doLookup(dataSourceName);
} }
final InitialContext context = new InitialContext(jndiProperties); final InitialContext context = new InitialContext(jndiProperties);
return (DataSource) context.doLookup(dataSourceName); return (DataSource) context.lookup(dataSourceName);
} catch (Exception e) { } catch (Exception e) {
throw new DeviceManagementException( String msg = "Error in looking up data source: " + e.getMessage();
"Error in looking up data source: " + e.getMessage(), e); log.error(msg, e);
} throw new DeviceManagementException(msg, e);
} }
}
public static void cleanupResources(Connection conn, PreparedStatement stmt, ResultSet rs) { public static void cleanupResources(Connection conn, PreparedStatement stmt, ResultSet rs) {
if (rs != null) { if (rs != null) {
try { try {
rs.close(); rs.close();
} catch (SQLException e) { } catch (SQLException e) {
log.warn("Error occurred while closing result set", e); log.warn("Error occurred while closing result set", e);
} }
} }
if (stmt != null) { if (stmt != null) {
try { try {
stmt.close(); stmt.close();
} catch (SQLException e) { } catch (SQLException e) {
log.warn("Error occurred while closing prepared statement", e); log.warn("Error occurred while closing prepared statement", e);
} }
} }
if (conn != null) { if (conn != null) {
try { try {
conn.close(); conn.close();
} catch (SQLException e) { } catch (SQLException e) {
log.warn("Error occurred while closing database connection", e); log.warn("Error occurred while closing database connection", e);
} }
} }
} }
/** /**
* Initializes the creation of mobile device management schema if -Dsetup has provided. * Initializes the creation of mobile device management schema if -Dsetup has provided.
* *
* @param dataSource Mobile data source * @param dataSource Mobile data source
*/ */
public static void createDataSource(DataSource dataSource) { public static void createDataSource(DataSource dataSource) {
String setupOption = System.getProperty("setup"); String setupOption = System.getProperty("setup");
if (setupOption != null) { if (setupOption != null) {
if (log.isDebugEnabled()) { if (log.isDebugEnabled()) {
log.debug( log.debug(
"-Dsetup is enabled. Mobile Device management repository schema initialization is about " + "-Dsetup is enabled. Mobile Device management repository schema initialization is about " +
"to begin"); "to begin");
} }
try { try {
MobileDeviceManagementDAOUtil.setupMobileDeviceManagementSchema(dataSource); MobileDeviceManagementDAOUtil.setupMobileDeviceManagementSchema(dataSource);
} catch (DeviceManagementException e) { } catch (DeviceManagementException e) {
log.error( log.error("Exception occurred while initializing mobile device management database schema", e);
"Exception occurred while initializing mobile device management database schema", }
e); }
} }
}
}
/** /**
* Creates the mobile device management schema. * Creates the mobile device management schema.
* *
* @param dataSource Mobile data source * @param dataSource Mobile data source
*/ */
public static void setupMobileDeviceManagementSchema(DataSource dataSource) throws public static void setupMobileDeviceManagementSchema(DataSource dataSource) throws
DeviceManagementException { DeviceManagementException {
MobileDeviceManagementSchemaInitializer initializer = MobileDeviceManagementSchemaInitializer initializer =
new MobileDeviceManagementSchemaInitializer(dataSource); new MobileDeviceManagementSchemaInitializer(dataSource);
log.info("Initializing mobile device management repository database schema"); log.info("Initializing mobile device management repository database schema");
try { try {
initializer.createRegistryDatabase(); initializer.createRegistryDatabase();
} catch (Exception e) { } catch (Exception e) {
throw new DeviceManagementException( throw new DeviceManagementException("Error occurred while initializing Mobile Device Management " +
"Error occurred while initializing Mobile Device Management " + "database schema", e);
"database schema", e); }
} }
}
} }

@ -47,7 +47,7 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
@Override @Override
public boolean enrollDevice(Device device) throws DeviceManagementException { public boolean enrollDevice(Device device) throws DeviceManagementException {
boolean status = false; boolean status;
MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device); MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device);
try { try {
status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO().addDevice(mobileDevice); status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO().addDevice(mobileDevice);
@ -62,7 +62,7 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
@Override @Override
public boolean modifyEnrollment(Device device) throws DeviceManagementException { public boolean modifyEnrollment(Device device) throws DeviceManagementException {
boolean status = false; boolean status;
MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device); MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device);
try { try {
status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO() status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO()
@ -78,7 +78,7 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
@Override @Override
public boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException { public boolean disenrollDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
boolean status = false; boolean status;
try { try {
status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO() status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO()
.deleteDevice(deviceId.getId()); .deleteDevice(deviceId.getId());
@ -122,7 +122,7 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
@Override @Override
public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException { public Device getDevice(DeviceIdentifier deviceId) throws DeviceManagementException {
Device device = null; Device device;
try { try {
MobileDevice mobileDevice = MobileDeviceManagementDAOFactory.getMobileDeviceDAO(). MobileDevice mobileDevice = MobileDeviceManagementDAOFactory.getMobileDeviceDAO().
getDevice(deviceId.getId()); getDevice(deviceId.getId());
@ -143,14 +143,13 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
@Override @Override
public boolean updateDeviceInfo(Device device) throws DeviceManagementException { public boolean updateDeviceInfo(Device device) throws DeviceManagementException {
boolean status = false; boolean status;
MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device); MobileDevice mobileDevice = MobileDeviceManagementUtil.convertToMobileDevice(device);
try { try {
status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO() status = MobileDeviceManagementDAOFactory.getMobileDeviceDAO()
.updateDevice(mobileDevice); .updateDevice(mobileDevice);
} catch (MobileDeviceManagementDAOException e) { } catch (MobileDeviceManagementDAOException e) {
String msg = String msg = "Error while updating the Android device : " + device.getDeviceIdentifier();
"Error while updating the Android device : " + device.getDeviceIdentifier();
log.error(msg, e); log.error(msg, e);
throw new DeviceManagementException(msg, e); throw new DeviceManagementException(msg, e);
} }
@ -166,9 +165,9 @@ public class AndroidDeviceManagerService implements DeviceManagerService {
getAllDevices(); getAllDevices();
if (mobileDevices != null) { if (mobileDevices != null) {
devices = new ArrayList<Device>(); devices = new ArrayList<Device>();
for (int x = 0; x < mobileDevices.size(); x++) { for (MobileDevice mobileDevice : mobileDevices) {
devices.add(MobileDeviceManagementUtil.convertToDevice(mobileDevices.get(x))); devices.add(MobileDeviceManagementUtil.convertToDevice(mobileDevice));
} }
} }
} catch (MobileDeviceManagementDAOException e) { } catch (MobileDeviceManagementDAOException e) {
String msg = "Error while fetching all Android devices."; String msg = "Error while fetching all Android devices.";

@ -88,5 +88,4 @@ public class IOSDeviceManagerService implements DeviceManagerService {
return true; return true;
} }
} }

@ -105,7 +105,7 @@ public class MobileDeviceManagementBundleActivator implements BundleActivator, B
services */ services */
this.removeAPIs(); this.removeAPIs();
} catch (Throwable e) { } catch (Throwable e) {
log.error("Error occurred while de-activating Mobile Device Management bundle"); log.error("Error occurred while de-activating Mobile Device Management bundle", e);
} }
} }

@ -0,0 +1,165 @@
/**
* Copyright (c) 2015, 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.mobile.internal;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.osgi.framework.BundleContext;
import org.osgi.framework.ServiceRegistration;
import org.osgi.service.component.ComponentContext;
import org.wso2.carbon.apimgt.api.APIManagementException;
import org.wso2.carbon.apimgt.api.APIProvider;
import org.wso2.carbon.apimgt.impl.APIManagerConfigurationService;
import org.wso2.carbon.apimgt.impl.APIManagerFactory;
import org.wso2.carbon.device.mgt.common.DeviceManagementException;
import org.wso2.carbon.device.mgt.common.spi.DeviceManagerService;
import org.wso2.carbon.device.mgt.mobile.config.APIConfig;
import org.wso2.carbon.device.mgt.mobile.config.MobileDeviceConfigurationManager;
import org.wso2.carbon.device.mgt.mobile.config.MobileDeviceManagementConfig;
import org.wso2.carbon.device.mgt.mobile.config.datasource.MobileDataSourceConfig;
import org.wso2.carbon.device.mgt.mobile.dao.MobileDeviceManagementDAOFactory;
import org.wso2.carbon.device.mgt.mobile.impl.android.AndroidDeviceManagerService;
import org.wso2.carbon.device.mgt.mobile.impl.ios.IOSDeviceManagerService;
import org.wso2.carbon.device.mgt.mobile.impl.windows.WindowsDeviceManagerService;
import org.wso2.carbon.device.mgt.mobile.util.DeviceManagementAPIPublisherUtil;
import java.util.List;
/**
* @scr.component name="org.wso2.carbon.device.mgt.mobile.impl.internal.MobileDeviceManagementServiceComponent"
* immediate="true"
* @scr.reference name="api.manager.config.service"
* interface="org.wso2.carbon.apimgt.impl.APIManagerConfigurationService"
* cardinality="1..1"
* policy="dynamic"
* bind="setAPIManagerConfigurationService"
* unbind="unsetAPIManagerConfigurationService"
* <p/>
* Adding reference to API Manager Configuration service is an unavoidable hack to get rid of NPEs thrown while
* initializing APIMgtDAOs attempting to register APIs programmatically. APIMgtDAO needs to be proper cleaned up
* to avoid as an ideal fix
*/
public class MobileDeviceManagementServiceComponent {
private ServiceRegistration androidServiceRegRef;
private ServiceRegistration iOSServiceRegRef;
private ServiceRegistration windowsServiceRegRef;
private static final Log log = LogFactory.getLog(MobileDeviceManagementServiceComponent.class);
protected void activate(ComponentContext ctx) {
if (log.isDebugEnabled()) {
log.debug("Activating Mobile Device Management Service Component");
}
try {
BundleContext bundleContext = ctx.getBundleContext();
/* Initialize the datasource configuration */
MobileDeviceConfigurationManager.getInstance().initConfig();
MobileDeviceManagementConfig config = MobileDeviceConfigurationManager.getInstance()
.getMobileDeviceManagementConfig();
MobileDataSourceConfig dsConfig =
config.getMobileDeviceMgtRepository().getMobileDataSourceConfig();
MobileDeviceManagementDAOFactory.setMobileDataSourceConfig(dsConfig);
androidServiceRegRef =
bundleContext.registerService(DeviceManagerService.class.getName(),
new AndroidDeviceManagerService(), null);
iOSServiceRegRef =
bundleContext.registerService(DeviceManagerService.class.getName(),
new IOSDeviceManagerService(), null);
windowsServiceRegRef =
bundleContext.registerService(DeviceManagerService.class.getName(),
new WindowsDeviceManagerService(), null);
/* Initialize all API configurations with corresponding API Providers */
this.initAPIConfigs();
/* Publish all mobile device management related JAX-RS services as APIs */
this.publishAPIs();
if (log.isDebugEnabled()) {
log.debug("Mobile Device Management Service Component has been successfully activated");
}
} catch (Throwable e) {
log.error("Error occurred while activating Mobile Device Management Service Component", e);
}
}
protected void deactivate(ComponentContext ctx) {
if (log.isDebugEnabled()) {
log.debug("De-activating Mobile Device Management Service Component");
}
try {
BundleContext bundleContext = ctx.getBundleContext();
androidServiceRegRef.unregister();
iOSServiceRegRef.unregister();
windowsServiceRegRef.unregister();
/* Removing all APIs published upon start-up for mobile device management related JAX-RS
services */
this.removeAPIs();
if (log.isDebugEnabled()) {
log.debug("Mobile Device Management Service Component has been successfully de-activated");
}
} catch (Throwable e) {
log.error("Error occurred while de-activating Mobile Device Management bundle", e);
}
}
private void initAPIConfigs() throws DeviceManagementException {
List<APIConfig> apiConfigs =
MobileDeviceConfigurationManager.getInstance().getMobileDeviceManagementConfig().
getApiPublisherConfig().getAPIs();
for (APIConfig apiConfig : apiConfigs) {
try {
APIProvider provider = APIManagerFactory.getInstance().getAPIProvider(apiConfig.getOwner());
apiConfig.init(provider);
} catch (APIManagementException e) {
throw new DeviceManagementException("Error occurred while initializing API Config '" +
apiConfig.getName() + "'", e);
}
}
}
private void publishAPIs() throws DeviceManagementException {
List<APIConfig> apiConfigs =
MobileDeviceConfigurationManager.getInstance().getMobileDeviceManagementConfig().
getApiPublisherConfig().getAPIs();
for (APIConfig apiConfig : apiConfigs) {
DeviceManagementAPIPublisherUtil.publishAPI(apiConfig);
}
}
private void removeAPIs() throws DeviceManagementException {
List<APIConfig> apiConfigs =
MobileDeviceConfigurationManager.getInstance().getMobileDeviceManagementConfig().
getApiPublisherConfig().getAPIs();
for (APIConfig apiConfig : apiConfigs) {
DeviceManagementAPIPublisherUtil.removeAPI(apiConfig);
}
}
protected void setAPIManagerConfigurationService(APIManagerConfigurationService service) {
//do nothing
}
protected void unsetAPIManagerConfigurationService(APIManagerConfigurationService service) {
//do nothing
}
}

@ -19,7 +19,7 @@
<ManagementRepository> <ManagementRepository>
<DataSourceConfiguration> <DataSourceConfiguration>
<JndiLookupDefinition> <JndiLookupDefinition>
<Name>jdbc/MOBILE_MGT_DS</Name> <Name>jdbc/MobileDM_DS</Name>
</JndiLookupDefinition> </JndiLookupDefinition>
</DataSourceConfiguration> </DataSourceConfiguration>
</ManagementRepository> </ManagementRepository>
@ -28,7 +28,7 @@
<APIs> <APIs>
<API> <API>
<Name>enrollment</Name> <Name>enrollment</Name>
<Provider>admin</Provider> <Owner>admin</Owner>
<Context>enrollment</Context> <Context>enrollment</Context>
<Version>1.0.0</Version> <Version>1.0.0</Version>
<Endpoint>http://localhost:9763/</Endpoint> <Endpoint>http://localhost:9763/</Endpoint>

@ -18,7 +18,7 @@
<ManagementRepository> <ManagementRepository>
<DataSourceConfiguration> <DataSourceConfiguration>
<JndiLookupDefinition> <JndiLookupDefinition>
<Name>jdbc/DEVICE_MGT_DS</Name> <Name>jdbc/DM_DS</Name>
</JndiLookupDefinition> </JndiLookupDefinition>
</DataSourceConfiguration> </DataSourceConfiguration>
</ManagementRepository> </ManagementRepository>

@ -0,0 +1,26 @@
CREATE TABLE IF NOT EXISTS DM_DEVICE_TYPE
(
ID INT(11) auto_increment NOT NULL,
NAME VARCHAR(300) NULL DEFAULT NULL,
PRIMARY KEY (ID)
);
CREATE TABLE IF NOT EXISTS DM_DEVICE
(
ID INT auto_increment NOT NULL,
DESCRIPTION TEXT NULL DEFAULT NULL,
NAME VARCHAR(100) NULL DEFAULT NULL,
DATE_OF_ENROLLMENT BIGINT NULL DEFAULT NULL,
DATE_OF_LAST_UPDATE BIGINT NULL DEFAULT NULL,
OWNERSHIP VARCHAR(45) NULL DEFAULT NULL,
STATUS VARCHAR(15) NULL DEFAULT NULL,
DEVICE_TYPE_ID INT(11) NULL DEFAULT NULL,
DEVICE_IDENTIFICATION VARCHAR(300) NULL DEFAULT NULL,
OWNER VARCHAR(45) NULL DEFAULT NULL,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (ID),
CONSTRAINT fk_DM_DEVICE_DM_DEVICE_TYPE2 FOREIGN KEY (DEVICE_TYPE_ID )
REFERENCES DM_DEVICE_TYPE (ID ) ON DELETE NO ACTION ON UPDATE NO ACTION
);
-- TO:DO - Remove this INSERT sql statement.
Insert into DM_DEVICE_TYPE (ID,NAME) VALUES (1, 'android');

@ -0,0 +1,35 @@
-- -----------------------------------------------------
-- Table `DM_DEVICE_TYPE`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `DM_DEVICE_TYPE` (
`ID` INT(11) NOT NULL ,
`NAME` VARCHAR(300) NULL DEFAULT NULL ,
PRIMARY KEY (`ID`) )
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;
-- -----------------------------------------------------
-- Table `DM_DEVICE`
-- -----------------------------------------------------
CREATE TABLE IF NOT EXISTS `DM_DEVICE` (
`ID` VARCHAR(20) NOT NULL ,
`DESCRIPTION` TEXT NULL DEFAULT NULL ,
`NAME` VARCHAR(100) NULL DEFAULT NULL ,
`DATE_OF_ENROLLMENT` DATETIME NULL DEFAULT NULL ,
`DATE_OF_LAST_UPDATE` DATETIME NULL DEFAULT NULL ,
`OWNERSHIP` VARCHAR(45) NULL DEFAULT NULL ,
`STATUS` VARCHAR(15) NULL DEFAULT NULL ,
`DEVICE_TYPE_ID` INT(11) NULL DEFAULT NULL ,
`DEVICE_IDENTIFICATION` VARCHAR(300) NULL DEFAULT NULL ,
`OWNER` VARCHAR(45) NULL DEFAULT NULL ,
TENANT_ID INTEGER DEFAULT 0,
PRIMARY KEY (`ID`) ,
INDEX `fk_DM_DEVICE_DM_DEVICE_TYPE2_idx` (`DEVICE_TYPE_ID` ASC) ,
CONSTRAINT `fk_DM_DEVICE_DM_DEVICE_TYPE2`
FOREIGN KEY (`DEVICE_TYPE_ID` )
REFERENCES `DM_DEVICE_TYPE` (`ID` )
ON DELETE NO ACTION
ON UPDATE NO ACTION)
ENGINE = InnoDB
DEFAULT CHARACTER SET = latin1;

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

@ -98,6 +98,40 @@
<artifactId>maven-antrun-plugin</artifactId> <artifactId>maven-antrun-plugin</artifactId>
<!--<version>${maven-antrun-plugin.version}</version>--> <!--<version>${maven-antrun-plugin.version}</version>-->
<executions> <executions>
<execution>
<!-- Creating Device Management schema -->
<id>create-device-mgt-schema</id>
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo
message="########### Create Device Management H2 Schema ###########"/>
<property name="db.dir"
value="target/wso2carbon-core-${carbon.kernel.version}/repository/database"/>
<property name="userid" value="wso2carbon"/>
<property name="password" value="wso2carbon"/>
<property name="dbURL"
value="jdbc:h2:file:${basedir}/${db.dir}/WSO2DM_DB;DB_CLOSE_ON_EXIT=FALSE"/>
<sql driver="org.h2.Driver"
url="${dbURL}"
userid="${userid}" password="${password}"
autocommit="true" onerror="continue">
<classpath refid="maven.dependency.classpath"/>
<classpath refid="maven.compile.classpath"/>
<classpath refid="maven.runtime.classpath"/>
<fileset file="${basedir}/../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/dbscripts/cdm/h2.sql"/>
</sql>
<echo
message="##################### END ####################"/>
</tasks>
</configuration>
</execution>
<execution> <execution>
<!-- Creating IDP Management schema --> <!-- Creating IDP Management schema -->
<id>create-idp-mgt-schema</id> <id>create-idp-mgt-schema</id>
@ -132,6 +166,40 @@
</tasks> </tasks>
</configuration> </configuration>
</execution> </execution>
<execution>
<!-- Creating API Management schema -->
<id>create-api-mgt-schema</id>
<phase>package</phase>
<goals>
<goal>run</goal>
</goals>
<configuration>
<tasks>
<echo
message="########### Create API Management H2 Schema ###########"/>
<property name="db.dir"
value="target/wso2carbon-core-${carbon.kernel.version}/repository/database"/>
<property name="userid" value="wso2carbon"/>
<property name="password" value="wso2carbon"/>
<property name="dbURL"
value="jdbc:h2:file:${basedir}/${db.dir}/WSO2AM_DB;DB_CLOSE_ON_EXIT=FALSE"/>
<sql driver="org.h2.Driver"
url="${dbURL}"
userid="${userid}" password="${password}"
autocommit="true" onerror="continue">
<classpath refid="maven.dependency.classpath"/>
<classpath refid="maven.compile.classpath"/>
<classpath refid="maven.runtime.classpath"/>
<fileset file="${basedir}/../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/dbscripts/apimgt/h2.sql"/>
</sql>
<echo
message="##################### END ####################"/>
</tasks>
</configuration>
</execution>
<execution> <execution>
<id>3-extract-docs-from-components</id> <id>3-extract-docs-from-components</id>
<phase>package</phase> <phase>package</phase>

@ -187,6 +187,17 @@
</includes> </includes>
</fileSet> </fileSet>
<!-- Copying API management related dbscripts -->
<fileSet>
<directory>
../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/dbscripts/apimgt
</directory>
<outputDirectory>wso2cdm-${project.version}/dbscripts/apimgt</outputDirectory>
<includes>
<include>*/**</include>
</includes>
</fileSet>
<fileSet> <fileSet>
<directory> <directory>
../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/repository/modules ../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/repository/modules
@ -197,10 +208,10 @@
</includes> </includes>
</fileSet> </fileSet>
<!-- Script --> <!-- Copying Device Management related dbscripts -->
<fileSet> <fileSet>
<directory>src/repository/dbscripts/</directory> <directory>../p2-profile-gen/target/wso2carbon-core-${carbon.kernel.version}/dbscripts/cdm</directory>
<outputDirectory>wso2cdm-${project.version}/dbscripts</outputDirectory> <outputDirectory>wso2cdm-${project.version}/dbscripts/cdm</outputDirectory>
<includes> <includes>
<include>*/**</include> <include>*/**</include>
</includes> </includes>
@ -220,6 +231,7 @@
<fileMode>755</fileMode> <fileMode>755</fileMode>
</fileSet> </fileSet>
</fileSets> </fileSets>
<dependencySets> <dependencySets>
<dependencySet> <dependencySet>
<outputDirectory>wso2cdm-${project.version}/lib/endorsed</outputDirectory> <outputDirectory>wso2cdm-${project.version}/lib/endorsed</outputDirectory>
@ -238,7 +250,6 @@
</dependencySets> </dependencySets>
<files> <files>
<file> <file>
<source>../agents/android/jax-rs/target/cdm-android-api.war</source> <source>../agents/android/jax-rs/target/cdm-android-api.war</source>
<outputDirectory>wso2cdm-${pom.version}/repository/deployment/server/webapps <outputDirectory>wso2cdm-${pom.version}/repository/deployment/server/webapps
@ -429,6 +440,25 @@
<fileMode>644</fileMode> <fileMode>644</fileMode>
</file> </file>
<!-- Copying H2 database related files corresponding to default API management repository schema -->
<file>
<source>
target/wso2carbon-core-${carbon.kernel.version}/repository/database/WSO2AM_DB.h2.db
</source>
<outputDirectory>${pom.artifactId}-${pom.version}/repository/database</outputDirectory>
<destName>WSO2AM_DB.h2.db</destName>
<fileMode>644</fileMode>
</file>
<!-- Copying H2 database related files corresponding to default Device management repository schema -->
<file>
<source>
target/wso2carbon-core-${carbon.kernel.version}/repository/database/WSO2DM_DB.h2.db
</source>
<outputDirectory>${pom.artifactId}-${pom.version}/repository/database</outputDirectory>
<destName>WSO2DM_DB.h2.db</destName>
<fileMode>644</fileMode>
</file>
</files> </files>
</assembly> </assembly>

@ -5,14 +5,14 @@
<datasources> <datasources>
<datasource> <datasource>
<name>DEVICE_MGT_DS</name> <name>DM_DS</name>
<description>The datasource used for CDM</description> <description>The datasource used for CDM</description>
<jndiConfig> <jndiConfig>
<name>jdbc/DEVICE_MGT_DS</name> <name>jdbc/DM_DS</name>
</jndiConfig> </jndiConfig>
<definition type="RDBMS"> <definition type="RDBMS">
<configuration> <configuration>
<url>jdbc:h2:repository/database/WSO2DEVICEMGT_DB;DB_CLOSE_ON_EXIT=FALSE</url> <url>jdbc:h2:repository/database/WSO2DM_DB;DB_CLOSE_ON_EXIT=FALSE</url>
<username>wso2carbon</username> <username>wso2carbon</username>
<password>wso2carbon</password> <password>wso2carbon</password>
<driverClassName>org.h2.Driver</driverClassName> <driverClassName>org.h2.Driver</driverClassName>
@ -25,14 +25,14 @@
</definition> </definition>
</datasource> </datasource>
<datasource> <datasource>
<name>MOBILE_MGT_DS</name> <name>MobileDM_DS</name>
<description>The datasource used for CDM Mobile Device Management</description> <description>The datasource used for CDM Mobile Device Management</description>
<jndiConfig> <jndiConfig>
<name>jdbc/MOBILE_MGT_DS</name> <name>jdbc/MobileDM_DS</name>
</jndiConfig> </jndiConfig>
<definition type="RDBMS"> <definition type="RDBMS">
<configuration> <configuration>
<url>jdbc:h2:repository/database/WSO2MOBILE_DB;DB_CLOSE_ON_EXIT=FALSE</url> <url>jdbc:h2:repository/database/WSO2MobileDM_DB;DB_CLOSE_ON_EXIT=FALSE</url>
<username>wso2carbon</username> <username>wso2carbon</username>
<password>wso2carbon</password> <password>wso2carbon</password>
<driverClassName>org.h2.Driver</driverClassName> <driverClassName>org.h2.Driver</driverClassName>
@ -45,7 +45,7 @@
</definition> </definition>
</datasource> </datasource>
<datasource> <datasource>
<name>WSO2DEVICE_DB</name> <name>WSO2AM_DS</name>
<description>The datasource used for CDM</description> <description>The datasource used for CDM</description>
<jndiConfig> <jndiConfig>
<name>jdbc/WSO2AM_DB</name> <name>jdbc/WSO2AM_DB</name>

@ -35,11 +35,48 @@
<name>WSO2 CDM - Integration Test Ui Pages</name> <name>WSO2 CDM - Integration Test Ui Pages</name>
<dependencies> <dependencies>
<dependency> <dependency>
<groupId>org.wso2.carbon</groupId> <groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.integration.common.admin.client</artifactId> <artifactId>org.wso2.carbon.integration.common.admin.client</artifactId>
<scope>compile</scope> <scope>compile</scope>
<exclusions>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.user.mgt.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.logging.view.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.ndatasource.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.server.admin.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.throttle.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.tenant.mgt.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.application.mgt.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.security.mgt.stub</artifactId>
</exclusion>
<exclusion>
<groupId>org.wso2.carbon</groupId>
<artifactId>org.wso2.carbon.identity.user.profile.stub</artifactId>
</exclusion>
</exclusions>
</dependency> </dependency>
<dependency> <dependency>
<groupId>org.wso2.carbon.automation</groupId> <groupId>org.wso2.carbon.automation</groupId>

Loading…
Cancel
Save