<!--
  ~ Copyright (c) 2017 CEA.
  ~ All rights reserved. This program and the accompanying materials
  ~ are made available under the terms of the Eclipse Public License v1.0
  ~ which accompanies this distribution, and is available at
  ~ http://www.eclipse.org/legal/epl-v10.html
  ~
  ~ Contributors:
  ~    CEA - initial API and implementation
  -->

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <parent>
        <groupId>org.eclipse.sensinact.gateway</groupId>
        <artifactId>parent</artifactId>
        <version>2.0-SNAPSHOT</version>
    </parent>

    <artifactId>sensinact-security</artifactId>
    <packaging>pom</packaging>

	<name>sensiNact IoT Gateway - Security parent module</name>

	<properties>
		<cert.path>../cert/keystore.jks</cert.path>
    </properties>

	<modules>
		<module>sensinact-framework-extension</module>
		<module>sensinact-security-none</module>
		<!--<module>sensinact-mail-connector</module>-->
		<!--<module>sensinact-signature-validator</module>-->
        <!--<module>sensinact-security-core</module>-->
	</modules>
	
</project>
