Develop

pom.xml

@@ -14,11 +14,12 @@
 	<parent>
 		<groupId>org.springframework.boot</groupId>
 		<artifactId>spring-boot-starter-parent</artifactId>
-		<version>2.0.2.RELEASE</version>
+        <version>1.4.2.RELEASE</version>
 		<relativePath/> <!-- lookup parent from repository -->
 	</parent>
 
 	<properties>
+		<powermock.version>1.7.4</powermock.version>
 		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
 		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
 		<java.version>1.8</java.version>
@@ -34,8 +35,14 @@
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-web</artifactId>
+			<exclusions>
+				<exclusion>
+					<groupId>org.springframework.boot</groupId>
+					<artifactId>spring-boot-starter-logging</artifactId>
+				</exclusion>
+			</exclusions>
 		</dependency>
-
+		
 		<dependency>
 			<groupId>org.springframework.boot</groupId>
 			<artifactId>spring-boot-starter-test</artifactId>
@@ -60,19 +67,63 @@
 			<version>2.8.0</version>
 			<scope>compile</scope>
 		</dependency>
-
+		
 		<dependency>
-			<groupId>fogbow</groupId>
-			<artifactId>common</artifactId>
-			<version>0.0.1-SNAPSHOT</version>
-		</dependency>
+            <groupId>fogbow</groupId>
+            <artifactId>fogbow-as</artifactId>
+            <version>0.0.1-SNAPSHOT</version>
+        </dependency>
+
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-module-junit4</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.powermock</groupId>
+            <artifactId>powermock-api-mockito</artifactId>
+            <version>${powermock.version}</version>
+            <scope>test</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.mockito</groupId>
+            <artifactId>mockito-all</artifactId>
+            <version>1.10.19</version>
+            <scope>test</scope>
+        </dependency>
 	</dependencies>
 
 	<build>
+	    <resources>
+            <resource>
+                <directory>src/main/resources/</directory>
+                <excludes>
+                    <exclude>examples/</exclude>
+                </excludes>
+            </resource>
+        </resources>
+        <testResources>
+            <testResource>
+                <directory>src/test/resources</directory>
+            </testResource>
+        </testResources>
 		<plugins>
 			<plugin>
 				<groupId>org.springframework.boot</groupId>
 				<artifactId>spring-boot-maven-plugin</artifactId>
+				<executions>
+                    <execution>
+                        <goals>
+                            <goal>repackage</goal>
+                        </goals>
+                        <configuration>
+                            <classifier>exec</classifier>
+                        </configuration>
+                    </execution>
+                </executions>
 			</plugin>
 		</plugins>
 	</build>

src/main/java/cloud/fogbow/ms/Main.java

@@ -0,0 +1,47 @@
+package cloud.fogbow.ms;
+
+import org.apache.log4j.Logger;
+import org.springframework.boot.ApplicationArguments;
+import org.springframework.boot.ApplicationRunner;
+import org.springframework.stereotype.Component;
+
+import cloud.fogbow.common.constants.FogbowConstants;
+import cloud.fogbow.common.exceptions.ConfigurationErrorException;
+import cloud.fogbow.common.exceptions.FatalErrorException;
+import cloud.fogbow.common.plugins.authorization.AuthorizationPlugin;
+import cloud.fogbow.common.util.ServiceAsymmetricKeysHolder;
+import cloud.fogbow.ms.core.ApplicationFacade;
+import cloud.fogbow.ms.core.MembershipService;
+import cloud.fogbow.ms.core.PluginInstantiator;
+import cloud.fogbow.ms.core.PropertiesHolder;
+import cloud.fogbow.ms.core.authorization.MsOperation;
+
+@Component
+public class Main implements ApplicationRunner {
+    private final Logger LOGGER = Logger.getLogger(Main.class);
+
+    @Override
+    public void run(ApplicationArguments args) throws ConfigurationErrorException {
+        try {
+            String publicKeyFilePath = PropertiesHolder.getInstance().getProperty(FogbowConstants.PUBLIC_KEY_FILE_PATH);
+            String privateKeyFilePath = PropertiesHolder.getInstance().getProperty(FogbowConstants.PRIVATE_KEY_FILE_PATH);
+            ServiceAsymmetricKeysHolder.getInstance().setPublicKeyFilePath(publicKeyFilePath);
+            ServiceAsymmetricKeysHolder.getInstance().setPrivateKeyFilePath(privateKeyFilePath);
+
+            AuthorizationPlugin<MsOperation> authorizationPlugin = PluginInstantiator.getAuthorizationPlugin();
+            MembershipService membershipService = PluginInstantiator.getMembershipService();
+
+            ApplicationFacade.getInstance().setMembershipService(membershipService);
+            ApplicationFacade.getInstance().setAuthorizationPlugin(authorizationPlugin);
+
+        } catch (FatalErrorException errorException) {
+            LOGGER.fatal(errorException.getMessage(), errorException);
+            tryExit();
+        }
+    }
+
+    private void tryExit() {
+        if (!Boolean.parseBoolean(System.getenv("SKIP_TEST_ON_TRAVIS")))
+            System.exit(1);
+    }
+}

src/main/java/cloud/fogbow/ms/api/http/CommonKeys.java

@@ -0,0 +1,5 @@
+package cloud.fogbow.ms.api.http;
+
+public class CommonKeys {
+    public static final String SYSTEM_USER_TOKEN_HEADER_KEY = "Fogbow-User-Token";
+}

src/main/java/cloud/fogbow/ms/api/http/MsExceptionToHttpErrorConditionTranslator.java

@@ -0,0 +1,9 @@
+package cloud.fogbow.ms.api.http;
+
+import org.springframework.web.bind.annotation.ControllerAdvice;
+import cloud.fogbow.common.http.FogbowExceptionToHttpErrorConditionTranslator;
+
+@ControllerAdvice
+public class MsExceptionToHttpErrorConditionTranslator extends FogbowExceptionToHttpErrorConditionTranslator {
+
+}

src/main/java/cloud/fogbow/ms/api/http/request/Admin.java

@@ -0,0 +1,83 @@
+package cloud.fogbow.ms.api.http.request;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestHeader;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import cloud.fogbow.common.exceptions.FogbowException;
+import cloud.fogbow.ms.api.http.CommonKeys;
+import cloud.fogbow.ms.api.parameters.Provider;
+import cloud.fogbow.ms.api.parameters.ProviderPermission;
+import cloud.fogbow.ms.api.parameters.Service;
+import cloud.fogbow.ms.constants.ApiDocumentation;
+import cloud.fogbow.ms.constants.SystemConstants;
+import cloud.fogbow.ms.core.ApplicationFacade;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+import io.swagger.annotations.ApiParam;
+
+@CrossOrigin
+@RestController
+@RequestMapping(value = Admin.ADMIN_ENDPOINT)
+@Api(description = ApiDocumentation.Admin.API)
+// TODO add documentation for parameters
+public class Admin {
+    public static final String ADMIN_ENDPOINT = SystemConstants.SERVICE_BASE_ENDPOINT + "admin";
+    public static final String RELOAD_ENDPOINT = "/reload";
+    public static final String SERVICE_ENDPOINT = "/service";
+    public static final String PROVIDER_ENDPOINT = "/provider";
+
+    @ApiOperation(value = ApiDocumentation.Admin.RELOAD)
+    @RequestMapping(value = RELOAD_ENDPOINT, method = RequestMethod.POST)
+    public ResponseEntity<Boolean> reload(
+    				@ApiParam(value = cloud.fogbow.common.constants.ApiDocumentation.Token.SYSTEM_USER_TOKEN)
+    				@RequestHeader(required = false, value = CommonKeys.SYSTEM_USER_TOKEN_HEADER_KEY) String systemUserToken) throws FogbowException {
+        ApplicationFacade.getInstance().reload(systemUserToken);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @ApiOperation(value = ApiDocumentation.Admin.SERVICE)
+    @RequestMapping(value = SERVICE_ENDPOINT, method = RequestMethod.POST)
+    public ResponseEntity<Boolean> service(
+                    @ApiParam(value = cloud.fogbow.common.constants.ApiDocumentation.Token.SYSTEM_USER_TOKEN)
+                    @RequestHeader(required = false, value = CommonKeys.SYSTEM_USER_TOKEN_HEADER_KEY)String systemUserToken,
+                    @RequestBody Service service) throws FogbowException {
+        ApplicationFacade.getInstance().updateMembershipService(systemUserToken, service.getClassName());
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @ApiOperation(value = ApiDocumentation.Admin.ADD_PROVIDER)
+    @RequestMapping(value = PROVIDER_ENDPOINT, method = RequestMethod.POST)
+    public ResponseEntity<Boolean> addProvider(
+    				@ApiParam(value = cloud.fogbow.common.constants.ApiDocumentation.Token.SYSTEM_USER_TOKEN)
+    				@RequestHeader(required = false, value = CommonKeys.SYSTEM_USER_TOKEN_HEADER_KEY) String systemUserToken,
+    				@RequestBody ProviderPermission provider) throws FogbowException {
+        ApplicationFacade.getInstance().addProvider(systemUserToken, provider);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @ApiOperation(value = ApiDocumentation.Admin.REMOVE_PROVIDER)
+    @RequestMapping(value = PROVIDER_ENDPOINT, method = RequestMethod.DELETE)
+    public ResponseEntity<Boolean> removeProvider(
+    				@ApiParam(value = cloud.fogbow.common.constants.ApiDocumentation.Token.SYSTEM_USER_TOKEN)
+    				@RequestHeader(required = false, value = CommonKeys.SYSTEM_USER_TOKEN_HEADER_KEY) String systemUserToken,
+    				@RequestBody Provider provider) throws FogbowException {
+    	ApplicationFacade.getInstance().removeProvider(systemUserToken, provider.getProvider());
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+
+    @ApiOperation(value = ApiDocumentation.Admin.UPDATE_PROVIDER)
+    @RequestMapping(value = PROVIDER_ENDPOINT, method = RequestMethod.PUT)
+    public ResponseEntity<Boolean> updateProvider(
+                    @ApiParam(value = cloud.fogbow.common.constants.ApiDocumentation.Token.SYSTEM_USER_TOKEN)
+                    @RequestHeader(required = false, value = CommonKeys.SYSTEM_USER_TOKEN_HEADER_KEY) String systemUserToken,
+                    @RequestBody ProviderPermission provider) throws FogbowException {
+        ApplicationFacade.getInstance().updateProvider(systemUserToken, provider);
+        return new ResponseEntity<>(HttpStatus.OK);
+    }
+}

src/main/java/cloud/fogbow/ms/api/http/request/Authorization.java

@@ -0,0 +1,44 @@
+package cloud.fogbow.ms.api.http.request;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.bind.annotation.CrossOrigin;
+import org.springframework.web.bind.annotation.RequestBody;
+import org.springframework.web.bind.annotation.RequestMapping;
+import org.springframework.web.bind.annotation.RequestMethod;
+import org.springframework.web.bind.annotation.RestController;
+
+import cloud.fogbow.ms.api.http.response.Authorized;
+import cloud.fogbow.ms.api.parameters.Provider;
+import cloud.fogbow.ms.constants.ApiDocumentation;
+import cloud.fogbow.ms.constants.SystemConstants;
+import cloud.fogbow.ms.core.ApplicationFacade;
+import io.swagger.annotations.Api;
+import io.swagger.annotations.ApiOperation;
+
+@CrossOrigin
+@RestController
+@RequestMapping(value = Authorization.AUTHORIZED_ENDPOINT)
+@Api(description = ApiDocumentation.Authorization.API)
+public class Authorization {
+    public static final String AUTHORIZED_ENDPOINT = SystemConstants.SERVICE_BASE_ENDPOINT + "authorized";
+    public static final String TARGET_AUTHORIZED_ENDPOINT = AUTHORIZED_ENDPOINT + "/target";
+    public static final String REQUESTER_AUTHORIZED_ENDPOINT = AUTHORIZED_ENDPOINT + "/requester";
+
+    @ApiOperation(value = ApiDocumentation.Authorization.TARGET_OPERATION)
+    @RequestMapping(value = "/target", method = RequestMethod.POST)
+    public ResponseEntity<Authorized> isTargetAuthorized(
+            @RequestBody Provider provider) {
+        boolean authorized = ApplicationFacade.getInstance().isTargetAuthorized(provider.getProvider());
+        return new ResponseEntity<Authorized>(new Authorized(authorized), HttpStatus.OK);
+    }
+
+    @ApiOperation(value = ApiDocumentation.Authorization.REQUESTER_OPERATION)
+    @RequestMapping(value = "/requester", method = RequestMethod.POST)
+    public ResponseEntity<Authorized> isRequesterAuthorized(
+            @RequestBody Provider provider) {
+        boolean authorized = ApplicationFacade.getInstance().isRequesterAuthorized(provider.getProvider());
+        return new ResponseEntity<Authorized>(new Authorized(authorized), HttpStatus.OK);
+    }
+
+}

src/main/java/cloud/fogbow/ms/api/http/request/Membership.java

@@ -1,11 +1,11 @@
 package cloud.fogbow.ms.api.http.request;
 
 import cloud.fogbow.ms.constants.SystemConstants;
-import cloud.fogbow.ms.core.service.WhiteList;
 import io.swagger.annotations.Api;
 import io.swagger.annotations.ApiOperation;
 import org.apache.log4j.Logger;
-import cloud.fogbow.ms.MembershipService;
+
+import cloud.fogbow.ms.core.ApplicationFacade;
 import cloud.fogbow.ms.constants.ApiDocumentation;
 import cloud.fogbow.ms.constants.Messages;
 import cloud.fogbow.ms.api.http.response.MembersList;
@@ -16,7 +16,6 @@
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RestController;
 
-import java.io.FileNotFoundException;
 import java.util.List;
 
 @CrossOrigin
@@ -29,14 +28,8 @@ public class Membership {
 
     private static final Logger LOGGER = Logger.getLogger(Membership.class);
 
-    private MembershipService membershipService;
-
     public Membership() {
-        try {
-            this.membershipService = new WhiteList();
-        } catch (FileNotFoundException e) {
-            LOGGER.error(String.format(Messages.Error.CONFIGURATION_FILE_NOT_FOUND), e);
-        }
+
     }
 
     /**
@@ -45,16 +38,12 @@ public Membership() {
     @ApiOperation(value = ApiDocumentation.Membership.DESCRIPTION)
     @GetMapping
     public ResponseEntity<MembersList> listMembers() {
-        if (this.membershipService == null) {
-            return new ResponseEntity<>(HttpStatus.NOT_FOUND);
-        }
-
         try {
-            List<String> membersId = this.membershipService.listMembers();
+            List<String> membersId = ApplicationFacade.getInstance().listMembers();
             MembersList membersList = new MembersList(membersId);
             return new ResponseEntity<MembersList>(membersList, HttpStatus.OK);
         } catch (Exception e) {
-            LOGGER.error(Messages.Error.INTERNAL_SERVER_ERROR, e);
+            LOGGER.error(Messages.Log.INTERNAL_SERVER_ERROR, e);
             return new ResponseEntity<>(HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }