diff --git a/config/api-manager.xml b/config/api-manager.xml
index 0312bfa176..c26b3aff54 100644
--- a/config/api-manager.xml
+++ b/config/api-manager.xml
@@ -12,32 +12,6 @@
false
-
-
-
-
-
-
-
-
-
-
-
+ false
+
org.wso2.carbon.apimgt.usage.publisher.APIMgtUsageDataBridgeDataPublisher
+
+
+ {tcp://localhost:7612/}
+
+
+ admin
+
+
+ admin
+
-
+
+
+
+ 4.0.0
+
+ org.wso2.carbon.apimgt
+ api-import-export
+ 1.0-SNAPSHOT
+
+ JAX-RS API Import Export
+ war
+
+
+
+
+ maven-compiler-plugin
+
+ 1.5
+ 1.5
+
+ 2.3.2
+
+
+ maven-war-plugin
+ 2.2
+
+ WEB-INF/lib/*.jar
+ ${project.artifactId}
+
+
+
+ maven-eclipse-plugin
+ 2.9
+
+
+ org.eclipse.jdt.core.javabuilder
+
+
+ org.wso2.developerstudio.eclipse.jaxrs.project.nature
+ org.eclipse.jdt.core.javanature
+
+
+
+
+
+
+
+
+ deploy
+
+ compile
+
+
+ org.apache.maven.plugins
+ maven-antrun-plugin
+ 1.7
+
+
+ compile
+
+ run
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+ client
+
+ test
+
+
+ org.codehaus.mojo
+ exec-maven-plugin
+ 1.2.1
+
+
+ test
+
+ java
+
+
+ demo.jaxrs.client.Client
+
+
+ http://localhost:9763/services
+
+
+
+
+
+
+
+
+
+
+
+
+ commons-httpclient
+ commons-httpclient
+ 3.1
+
+
+ org.apache.cxf
+ cxf-rt-transports-http
+ 2.6.1
+
+
+ org.apache.cxf
+ cxf-rt-frontend-jaxrs
+ 2.6.1
+
+
+ javax.ws.rs
+ jsr311-api
+ 1.1.1
+
+
+ org.wso2.carbon.apimgt
+ org.wso2.carbon.apimgt.impl
+ 1.2.4-SNAPSHOT
+
+
+ org.wso2.carbon.apimgt
+ org.wso2.carbon.apimgt.api
+ 1.2.4-SNAPSHOT
+
+
+ org.codehaus.jackson
+ jackson-mapper-asl
+ 1.8.5
+
+
+ com.google.code.gson
+ gson
+ 1.7.1
+
+
+ com.google.guava
+ guava
+ 18.0
+
+
+
+
+ codehaus
+ http://repository.codehaus.org/org/codehaus
+
+
+ wso2-nexus
+ WSO2 internal Repository
+ http://maven.wso2.org/nexus/content/groups/wso2-public/
+
+ true
+ daily
+ warn
+
+
+
+ wso2.releases
+ WSO2 internal Repository
+ http://maven.wso2.org/nexus/content/repositories/releases/
+
+ true
+ daily
+ ignore
+
+
+
+
\ No newline at end of file
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/APIExportException.java b/modules/api-import-export/src/main/java/apim/restful/importexport/APIExportException.java
new file mode 100644
index 0000000000..265e7c459f
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/APIExportException.java
@@ -0,0 +1,38 @@
+/*
+ *
+ * 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 apim.restful.importexport;
+
+/**
+ * This class is used for handling exceptions occur in API export
+ */
+public class APIExportException extends Exception {
+
+ public APIExportException(String msg) {
+ super(msg);
+ }
+
+ public APIExportException(String msg, Throwable e) {
+ super(msg, e);
+ }
+
+ public APIExportException(Throwable throwable) {
+ super(throwable);
+ }
+}
+
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportException.java b/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportException.java
new file mode 100644
index 0000000000..4ed47c01fa
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportException.java
@@ -0,0 +1,41 @@
+/*
+ *
+ * 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 apim.restful.importexport;
+
+/**
+ * This is the class to represent APIImportException. This exception is used to indicate the
+ * exceptions that might be occurred during API import process.
+ */
+public class APIImportException extends Exception {
+
+ String errorDescription;
+
+ public APIImportException(String errorMessage) {
+ this.errorDescription = errorMessage;
+ }
+
+ /**
+ * This method returns the error description to the caller.
+ *
+ * @return errorDescription a string which contains the error
+ */
+ public String getErrorDescription() {
+ return this.errorDescription;
+ }
+}
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportExportConstants.java b/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportExportConstants.java
new file mode 100644
index 0000000000..38b0a1f645
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/APIImportExportConstants.java
@@ -0,0 +1,77 @@
+/*
+ *
+ * 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 apim.restful.importexport;
+
+import java.io.File;
+
+/**
+ * This class contains all the constants required for API Import and Export
+ */
+public final class APIImportExportConstants {
+
+ //system dependent default path separator character, represented as a string
+ public static final String DIRECTORY_SEPARATOR = File.separator;
+ //string representing the false state when preserving the provider
+ public static final String STATUS_FALSE = "FALSE";
+ //length of the name of the temporary directory
+ public static final int TEMP_FILENAME_LENGTH = 5;
+ //system property for default temporary directory
+ public static final String TEMP_DIR = "java.io.tmpdir";
+ //name of the uploaded zip file
+ public static final String UPLOAD_FILE_NAME = "APIArchive.zip";
+ //location of the api JSON file
+ public static final String JSON_FILE_LOCATION = DIRECTORY_SEPARATOR + "Meta-information" + DIRECTORY_SEPARATOR +
+ "api.json";
+ //name of the id element tag of the api.json file
+ public static final String ID_ELEMENT = "id";
+ //name of the id element tag of the api.json file
+ public static final String PROVIDER_ELEMENT = "providerName";
+ //location of the api swagger definition file
+ public static final String SWAGGER_DEFINITION_LOCATION = DIRECTORY_SEPARATOR + "Meta-information" +
+ DIRECTORY_SEPARATOR + "swagger.json";
+ //location of the image
+ public static final String IMAGE_FILE_LOCATION = DIRECTORY_SEPARATOR + "Image" + DIRECTORY_SEPARATOR;
+ //name of the image
+ public static final String IMAGE_FILE_NAME = "icon";
+ //location of the documents JSON file
+ public static final String DOCUMENT_FILE_LOCATION = DIRECTORY_SEPARATOR + "Docs" + DIRECTORY_SEPARATOR +
+ "docs.json";
+ //name of the inline file type
+ public static final String INLINE_DOC_TYPE = "INLINE";
+ //name of the url file type
+ public static final String URL_DOC_TYPE = "URL";
+ //name of the physical file type
+ public static final String FILE_DOC_TYPE = "FILE";
+ //location of the in sequence
+ public static final String IN_SEQUENCE_LOCATION = DIRECTORY_SEPARATOR + "Sequences" + DIRECTORY_SEPARATOR +
+ "in-sequence" + DIRECTORY_SEPARATOR;
+ //location of the out sequence
+ public static final String OUT_SEQUENCE_LOCATION = DIRECTORY_SEPARATOR + "Sequences" + DIRECTORY_SEPARATOR +
+ "out-sequence" + DIRECTORY_SEPARATOR;
+ //location of the fault sequence
+ public static final String FAULT_SEQUENCE_LOCATION = DIRECTORY_SEPARATOR + "Sequences" + DIRECTORY_SEPARATOR +
+ "fault-sequence" + DIRECTORY_SEPARATOR;
+ //extension of xml files
+ public static final String XML_EXTENSION = ".xml";
+ //location of the wsdl file
+ public static final String WSDL_LOCATION = DIRECTORY_SEPARATOR + "WSDL" + DIRECTORY_SEPARATOR;
+ //extension of wsdl files
+ public static final String WSDL_EXTENSION = ".wsdl";
+
+}
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/APIService.java b/modules/api-import-export/src/main/java/apim/restful/importexport/APIService.java
new file mode 100644
index 0000000000..71b94afde6
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/APIService.java
@@ -0,0 +1,214 @@
+/*
+ *
+ * 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 apim.restful.importexport;
+
+
+import com.google.gson.Gson;
+
+import javax.ws.rs.GET;
+import javax.ws.rs.Path;
+import javax.ws.rs.POST;
+import javax.ws.rs.Consumes;
+import javax.ws.rs.Produces;
+import javax.ws.rs.QueryParam;
+import javax.ws.rs.core.Context;
+
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.ws.rs.core.Response.Status;
+
+import java.io.File;
+import java.io.InputStream;
+
+import apim.restful.importexport.utils.APIExportUtil;
+import apim.restful.importexport.utils.APIImportUtil;
+import apim.restful.importexport.utils.ArchiveGeneratorUtil;
+import apim.restful.importexport.utils.AuthenticatorUtil;
+import org.apache.commons.lang.RandomStringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.apache.cxf.jaxrs.ext.multipart.Multipart;
+
+import org.wso2.carbon.apimgt.api.APIManagementException;
+import org.wso2.carbon.apimgt.api.model.APIIdentifier;
+import org.wso2.carbon.apimgt.impl.utils.APIUtil;
+import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
+
+/**
+ * This class provides JAX-RS services for exporting and importing APIs.
+ * These services provides functionality for exporting and importing single API at a time.
+ */
+@Path("/")
+public class APIService {
+
+ private static final Log log = LogFactory.getLog(APIService.class);
+
+ /**
+ * This service exports an API from API Manager for a given API ID
+ * Meta information, API icon, documentation, WSDL and sequences are exported
+ * This service generates a zipped archive which contains all the above mentioned resources
+ * for a given API
+ *
+ * @param name Name of the API that needs to be exported
+ * @param version Version of the API that needs to be exported
+ * @param providerName Provider name of the API that needs to be exported
+ * @return Zipped API as the response to the service call
+ */
+ @GET
+ @Path("/export-api")
+ @Produces("application/zip")
+ public Response exportAPI(@QueryParam("name") String name, @QueryParam("version") String version,
+ @QueryParam("provider") String providerName, @Context HttpHeaders httpHeaders) {
+
+ String userName;
+ if (name == null || version == null || providerName == null) {
+ log.error("Invalid API Information ");
+
+ return Response.status(Response.Status.BAD_REQUEST).entity("Invalid API Information")
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+ log.info("Retrieving API for API-Id : " + name + "-" + version + "-" + providerName);
+ APIIdentifier apiIdentifier;
+ try {
+
+ Response authorizationResponse = AuthenticatorUtil.authorizeUser(httpHeaders);
+ if (!(Response.Status.OK.getStatusCode() == authorizationResponse.getStatus())) {
+ return authorizationResponse;
+ }
+
+ userName = AuthenticatorUtil.getAuthenticatedUserName();
+ //provider names with @ signs are only accepted
+ String apiDomain = MultitenantUtils.getTenantDomain(providerName);
+ String apiRequesterDomain = MultitenantUtils.getTenantDomain(userName);
+ //Allows to export APIs created only in current tenant domain
+ if (!apiDomain.equals(apiRequesterDomain)) {
+ //not authorized to export requested API
+ log.error("Not authorized to " +
+ "export API :" + name + "-" + version + "-" + providerName);
+ return Response.status(Response.Status.FORBIDDEN).entity("Not authorized to export API :" +
+ name + "-" + version + "-" + providerName).type(MediaType.APPLICATION_JSON).build();
+ }
+
+ apiIdentifier = new APIIdentifier(APIUtil.replaceEmailDomain(providerName), name, version);
+
+ //create temp location for storing API data to generate archive
+ String currentDirectory = System.getProperty(APIImportExportConstants.TEMP_DIR);
+ String createdFolders = File.separator + RandomStringUtils.
+ randomAlphanumeric(APIImportExportConstants.TEMP_FILENAME_LENGTH) + File.separator;
+ File exportFolder = new File(currentDirectory + createdFolders);
+ APIExportUtil.createDirectory(exportFolder.getPath());
+ String archiveBasePath = exportFolder.toString();
+
+ APIExportUtil.setArchiveBasePath(archiveBasePath);
+
+ Response apiResourceRetrievalResponse = APIExportUtil.retrieveApiToExport(apiIdentifier, userName);
+
+ //Retrieve resources : thumbnail, meta information, wsdl, sequences and documents
+ // available for the exporting API
+ if (!(Response.Status.OK.getStatusCode() == apiResourceRetrievalResponse.getStatus())) {
+ return apiResourceRetrievalResponse;
+ }
+
+ ArchiveGeneratorUtil.archiveDirectory(archiveBasePath);
+
+ log.info("API" + name + "-" + version + " exported successfully");
+
+ File file = new File(archiveBasePath + ".zip");
+ Response.ResponseBuilder response = Response.ok(file);
+ response.header("Content-Disposition", "attachment; filename=\"" + file.getName() +
+ "\"");
+ return response.build();
+
+ } catch (APIExportException e) {
+ log.error("APIExportException occurred while exporting ", e);
+ return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Internal Server Error")
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ }
+
+ /**
+ * This is the service which is used to import an API. All relevant API data will be included upon the creation of
+ * the API. Depending on the choice of the user, provider of the imported API will be preserved or modified.
+ *
+ * @param uploadedInputStream uploadedInputStream input stream from the REST request
+ * @param defaultProviderStatus user choice to keep or replace the API provider
+ * @param httpHeaders HTTP headers for the authentication mechanism
+ * @return response for the API process
+ */
+ @POST
+ @Path("/import-api")
+ @Consumes(MediaType.MULTIPART_FORM_DATA)
+ @Produces(MediaType.APPLICATION_JSON)
+ public Response importAPI(@Multipart("file") InputStream uploadedInputStream, @QueryParam("preserveProvider")
+ String defaultProviderStatus, @Context HttpHeaders httpHeaders) {
+
+ boolean isProviderPreserved = true;
+
+ //Check if the URL parameter value is specified, otherwise the default value "true" is used
+ if (APIImportExportConstants.STATUS_FALSE.equalsIgnoreCase(defaultProviderStatus)) {
+ isProviderPreserved = false;
+ }
+
+ try {
+ Response authorizationResponse = AuthenticatorUtil.authorizeUser(httpHeaders);
+
+ //Process continues only if the user is authorized
+ if (Response.Status.OK.getStatusCode() == authorizationResponse.getStatus()) {
+
+ String currentUser = AuthenticatorUtil.getAuthenticatedUserName();
+ APIImportUtil.initializeProvider(currentUser);
+
+ //Temporary directory is used to create the required folders
+ String currentDirectory = System.getProperty(APIImportExportConstants.TEMP_DIR);
+ String createdFolders = File.separator +
+ RandomStringUtils.randomAlphanumeric(APIImportExportConstants.TEMP_FILENAME_LENGTH) +
+ File.separator;
+ File importFolder = new File(currentDirectory + createdFolders);
+ boolean folderCreateStatus = importFolder.mkdirs();
+
+ //API import process starts only if the required folder is created successfully
+ if (folderCreateStatus) {
+
+ String uploadFileName = APIImportExportConstants.UPLOAD_FILE_NAME;
+ String absolutePath = currentDirectory + createdFolders;
+ APIImportUtil.transferFile(uploadedInputStream, uploadFileName, absolutePath);
+
+ String extractedFolderName = APIImportUtil.extractArchive(
+ new File(absolutePath + uploadFileName), absolutePath);
+
+ APIImportUtil.importAPI(absolutePath + extractedFolderName, currentUser, isProviderPreserved);
+
+ importFolder.deleteOnExit();
+ return Response.status(Status.CREATED).entity("API imported successfully.\n").build();
+ } else {
+ return Response.status(Status.BAD_REQUEST).build();
+ }
+ } else {
+ return Response.status(Status.UNAUTHORIZED).entity("Not authorized to import API.\n").build();
+ }
+ } catch (APIExportException e) {
+ return Response.status(Status.INTERNAL_SERVER_ERROR).entity("Error in initializing API provider.\n").build();
+ } catch (APIImportException e) {
+ String errorDetail = new Gson().toJson(e.getErrorDescription());
+ return Response.serverError().entity(errorDetail).build();
+ }
+ }
+}
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIExportUtil.java b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIExportUtil.java
new file mode 100644
index 0000000000..e26acf59f9
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIExportUtil.java
@@ -0,0 +1,630 @@
+/*
+ *
+ * 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 apim.restful.importexport.utils;
+
+import apim.restful.importexport.APIExportException;
+
+import com.google.gson.Gson;
+import com.google.gson.GsonBuilder;
+
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.apache.axiom.om.OMElement;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.apimgt.api.APIDefinition;
+import org.wso2.carbon.apimgt.api.APIManagementException;
+import org.wso2.carbon.apimgt.api.APIProvider;
+import org.wso2.carbon.apimgt.api.model.API;
+import org.wso2.carbon.apimgt.api.model.APIIdentifier;
+import org.wso2.carbon.apimgt.api.model.APIStatus;
+import org.wso2.carbon.apimgt.api.model.Documentation;
+import org.wso2.carbon.apimgt.impl.APIConstants;
+import org.wso2.carbon.apimgt.impl.APIManagerFactory;
+import org.wso2.carbon.apimgt.impl.definitions.APIDefinitionFromSwagger20;
+import org.wso2.carbon.apimgt.impl.utils.APIUtil;
+import org.wso2.carbon.context.CarbonContext;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+import org.wso2.carbon.context.RegistryType;
+import org.wso2.carbon.registry.api.Registry;
+import org.wso2.carbon.registry.api.RegistryException;
+import org.wso2.carbon.registry.api.Resource;
+import org.wso2.carbon.registry.core.RegistryConstants;
+import org.wso2.carbon.utils.multitenancy.MultitenantConstants;
+import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
+
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import javax.xml.namespace.QName;
+import javax.xml.stream.XMLStreamException;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.FileWriter;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.io.StringReader;
+
+import java.util.AbstractMap;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * This is the util class which consists of all the functions for exporting API
+ */
+public class APIExportUtil {
+
+ private static final Log log = LogFactory.getLog(APIExportUtil.class);
+ private static String archiveBasePath = null;
+
+ private APIExportUtil() {
+ }
+
+ /**
+ * Set base path where exporting archive should be generated
+ *
+ * @param path Temporary directory location
+ */
+ public static void setArchiveBasePath(String path) {
+ archiveBasePath = path;
+ }
+
+ /**
+ * Retrieve API provider
+ *
+ * @param userName User name
+ * @return APIProvider Provider of the supplied user name
+ * @throws APIExportException If an error occurs while retrieving the provider
+ */
+ public static APIProvider getProvider(String userName) throws APIExportException {
+ APIProvider provider;
+ try {
+ provider = APIManagerFactory.getInstance().getAPIProvider(userName);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Current provider retrieved successfully");
+ }
+
+ return provider;
+
+ } catch (APIManagementException e) {
+ log.error("Error while retrieving provider" + e.getMessage());
+ throw new APIExportException("Error while retrieving current provider", e);
+ }
+
+ }
+
+ /**
+ * Retrieve registry for the current tenant
+ *
+ * @param userName user name of the tenant
+ * @return Registry registry of the current tenant
+ */
+ public static Registry getRegistry(String userName) {
+ boolean isTenantFlowStarted = false;
+ String tenantDomain = MultitenantUtils.getTenantDomain(userName);
+ try {
+ if (tenantDomain != null && !MultitenantConstants.SUPER_TENANT_DOMAIN_NAME.equals(tenantDomain)) {
+ isTenantFlowStarted = true;
+ PrivilegedCarbonContext.startTenantFlow();
+ PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true);
+ }
+ Registry registry = CarbonContext.getThreadLocalCarbonContext().
+ getRegistry(RegistryType.SYSTEM_GOVERNANCE);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Registry of logged in user retrieved successfully");
+ }
+ return registry;
+
+ } finally {
+ if (isTenantFlowStarted) {
+ PrivilegedCarbonContext.endTenantFlow();
+ }
+ }
+ }
+
+ /**
+ * This method retrieves all meta information and registry resources required for an API to
+ * recreate
+ *
+ * @param apiID Identifier of the exporting API
+ * @param userName User name of the requester
+ * @return HttpResponse indicating whether resource retrieval got succeed or not
+ * @throws APIExportException If an error occurs while retrieving API related resources
+ */
+ public static Response retrieveApiToExport(APIIdentifier apiID, String userName) throws APIExportException {
+
+ API apiToReturn;
+ String archivePath = archiveBasePath.concat(File.separator + apiID.getApiName() + "-" +
+ apiID.getVersion());
+ //initializing provider
+ APIProvider provider = getProvider(userName);
+ //registry for the current user
+ Registry registry = APIExportUtil.getRegistry(userName);
+
+ int tenantId = APIUtil.getTenantId(userName);
+
+ //directory creation
+ APIExportUtil.createDirectory(archivePath);
+
+ try {
+ apiToReturn = provider.getAPI(apiID);
+ } catch (APIManagementException e) {
+ log.error("Unable to retrieve API", e);
+ return Response.status(Response.Status.NOT_FOUND).entity("Unable to retrieve API")
+ .type(MediaType.APPLICATION_JSON).
+ build();
+ }
+
+ //export thumbnail
+ exportAPIThumbnail(apiID, registry);
+
+ //export documents
+ List docList;
+ try {
+ docList = provider.getAllDocumentation(apiID);
+ } catch (APIManagementException e) {
+ log.error("Unable to retrieve API Documentation", e);
+ return Response.status(Response.Status.INTERNAL_SERVER_ERROR).entity("Internal Server Error")
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ if (!docList.isEmpty()) {
+ exportAPIDocumentation(docList, apiID, registry);
+ }
+
+ //export wsdl
+ String wsdlUrl = apiToReturn.getWsdlUrl();
+ if (wsdlUrl != null) {
+ exportWSDL(apiID, registry);
+ }
+
+ //export sequences
+ exportSequences(apiToReturn, apiID, tenantId, registry);
+
+ //set API status to created
+ apiToReturn.setStatus(APIStatus.CREATED);
+
+ //export meta information
+ exportMetaInformation(apiToReturn, registry);
+
+ return Response.ok().build();
+
+ }
+
+ /**
+ * Retrieve thumbnail image for the exporting API and store it in the archive directory
+ *
+ * @param apiIdentifier ID of the requesting API
+ * @param registry Current tenant registry
+ * @throws APIExportException If an error occurs while retrieving image from the registry or
+ * storing in the archive directory
+ */
+ private static void exportAPIThumbnail(APIIdentifier apiIdentifier, Registry registry) throws APIExportException {
+ String thumbnailUrl = APIConstants.API_IMAGE_LOCATION + RegistryConstants.PATH_SEPARATOR +
+ apiIdentifier.getProviderName() + RegistryConstants.PATH_SEPARATOR +
+ apiIdentifier.getApiName() + RegistryConstants.PATH_SEPARATOR +
+ apiIdentifier.getVersion() + RegistryConstants.PATH_SEPARATOR +
+ APIConstants.API_ICON_IMAGE;
+
+ InputStream imageDataStream = null;
+ OutputStream outputStream = null;
+ String archivePath = archiveBasePath.concat(File.separator + apiIdentifier.getApiName() +
+ "-" + apiIdentifier.getVersion());
+ try {
+ if (registry.resourceExists(thumbnailUrl)) {
+ Resource icon = registry.get(thumbnailUrl);
+
+ imageDataStream = icon.getContentStream();
+
+ String mediaType = icon.getMediaType();
+ String extension = getThumbnailFileType(mediaType);
+
+ if (extension != null) {
+ createDirectory(archivePath + File.separator + "Image");
+
+ outputStream = new FileOutputStream(archivePath + File.separator + "Image" + File.separator +
+ "icon." + extension);
+
+ IOUtils.copy(imageDataStream, outputStream);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Thumbnail image retrieved successfully");
+ }
+ }
+ }
+ } catch (IOException e) {
+ //Exception is ignored by logging due to the reason that Thumbnail is not essential for
+ // an API to be recreated
+ log.error("I/O error while writing API Thumbnail to file" + e.getMessage());
+ } catch (RegistryException e) {
+ log.error("Error while retrieving API Thumbnail " + e.getMessage());
+ } finally {
+ IOUtils.closeQuietly(imageDataStream);
+ IOUtils.closeQuietly(outputStream);
+ }
+ }
+
+ /**
+ * Retrieve content type of the thumbnail image for setting the exporting file extension
+ *
+ * @param mediaType Media type of the thumbnail registry resource
+ * @return File extension for the exporting image
+ */
+ private static String getThumbnailFileType(String mediaType) {
+ if (("image/png").equals(mediaType)) {
+ return "png";
+ } else if (("image/jpg").equals(mediaType)) {
+ return "jpg";
+ } else if ("image/jpeg".equals(mediaType)) {
+ return "jpeg";
+ } else if (("image/bmp").equals(mediaType)) {
+ return "bmp";
+ } else if (("image/gif").equals(mediaType)) {
+ return "gif";
+ } else {
+ //api gets imported without thumbnail
+ log.error("Unsupported media type for icon " + mediaType);
+ }
+
+ return null;
+ }
+
+ /**
+ * Retrieve documentation for the exporting API and store it in the archive directory
+ * FILE, INLINE and URL documentations are handled
+ *
+ * @param apiIdentifier ID of the requesting API
+ * @param registry Current tenant registry
+ * @param docList documentation list of the exporting API
+ * @throws APIExportException If an error occurs while retrieving documents from the
+ * registry or storing in the archive directory
+ */
+ public static void exportAPIDocumentation(List docList, APIIdentifier apiIdentifier,
+ Registry registry) throws APIExportException {
+ Gson gson = new GsonBuilder().setPrettyPrinting().create();
+ String archivePath = archiveBasePath.concat(File.separator + apiIdentifier.getApiName() + "-" +
+ apiIdentifier.getVersion());
+ createDirectory(archivePath + File.separator + "Docs");
+ InputStream fileInputStream = null;
+ OutputStream outputStream = null;
+ try {
+ for (Documentation doc : docList) {
+ String sourceType = doc.getSourceType().name();
+ if (Documentation.DocumentSourceType.FILE.toString().equalsIgnoreCase(sourceType)) {
+ String fileName = doc.getFilePath().substring(doc.getFilePath().
+ lastIndexOf(RegistryConstants.PATH_SEPARATOR) + 1);
+ String filePath = APIUtil.getDocumentationFilePath(apiIdentifier, fileName);
+
+ //check whether resource exists in the registry
+ Resource docFile = registry.get(filePath);
+ String localFilePath = File.separator + "Docs" + File.separator + fileName;
+ outputStream = new FileOutputStream(archivePath + localFilePath);
+ fileInputStream = docFile.getContentStream();
+
+ IOUtils.copy(fileInputStream, outputStream);
+
+ doc.setFilePath(localFilePath);
+
+ if (log.isDebugEnabled()) {
+ log.debug(fileName + " retrieved successfully");
+ }
+ }
+ }
+
+ String json = gson.toJson(docList);
+ writeFile(archivePath + File.separator + "Docs" + File.separator + "docs.json", json);
+
+ if (log.isDebugEnabled()) {
+ log.debug("API Documentation retrieved successfully");
+ }
+
+ } catch (IOException e) {
+ log.error("I/O error while writing API documentation to file" + e.getMessage());
+ throw new APIExportException("I/O error while writing API documentation to file", e);
+ } catch (RegistryException e) {
+ log.error("Error while retrieving documentation " + e.getMessage());
+ throw new APIExportException("Error while retrieving documentation", e);
+ } finally {
+ IOUtils.closeQuietly(fileInputStream);
+ IOUtils.closeQuietly(outputStream);
+ }
+ }
+
+ /**
+ * Retrieve WSDL for the exporting API and store it in the archive directory
+ *
+ * @param apiIdentifier ID of the requesting API
+ * @param registry Current tenant registry
+ * @throws APIExportException If an error occurs while retrieving WSDL from the registry or
+ * storing in the archive directory
+ */
+ public static void exportWSDL(APIIdentifier apiIdentifier, Registry registry) throws APIExportException {
+
+ InputStream wsdlStream = null;
+ OutputStream outputStream = null;
+ String archivePath = archiveBasePath.concat("/" + apiIdentifier.getApiName() + "-" +
+ apiIdentifier.getVersion());
+
+ try {
+ String wsdlPath = APIConstants.API_WSDL_RESOURCE_LOCATION +
+ apiIdentifier.getProviderName() + "--" + apiIdentifier.getApiName() +
+ apiIdentifier.getVersion() + ".wsdl";
+ if (registry.resourceExists(wsdlPath)) {
+ createDirectory(archivePath + File.separator + "WSDL");
+
+ Resource wsdl = registry.get(wsdlPath);
+
+ wsdlStream = wsdl.getContentStream();
+
+ outputStream = new FileOutputStream(archivePath + File.separator + "WSDL" + File.separator +
+ apiIdentifier.getApiName() + "-" + apiIdentifier.getVersion() + ".wsdl");
+
+ IOUtils.copy(wsdlStream, outputStream);
+
+ if (log.isDebugEnabled()) {
+ log.debug("WSDL file retrieved successfully");
+ }
+ }
+ } catch (IOException e) {
+ log.error("I/O error while writing WSDL to file" + e.getMessage());
+ throw new APIExportException("I/O error while writing WSDL to file", e);
+ } catch (RegistryException e) {
+ log.error("Error while retrieving WSDL " + e.getMessage());
+ throw new APIExportException("Error while retrieving WSDL", e);
+ } finally {
+ IOUtils.closeQuietly(wsdlStream);
+ IOUtils.closeQuietly(outputStream);
+ }
+ }
+
+ /**
+ * Retrieve available custom sequences for the exporting API
+ *
+ * @param api exporting API
+ * @param apiIdentifier ID of the requesting API
+ * @param registry current tenant registry
+ * @throws APIExportException If an error occurs while exporting sequences
+ */
+ public static void exportSequences(API api, APIIdentifier apiIdentifier, int tenantId, Registry registry)
+ throws APIExportException {
+
+ Map sequences = new HashMap();
+
+ if (api.getInSequence() != null) {
+ sequences.put(APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN, api.getInSequence());
+ }
+
+ if (api.getOutSequence() != null) {
+ sequences.put(APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT, api.getOutSequence());
+ }
+
+ if (api.getOutSequence() != null) {
+ sequences.put(APIConstants.API_CUSTOM_SEQUENCE_TYPE_FAULT, api.getFaultSequence());
+ }
+
+ if (!sequences.isEmpty()) {
+ String archivePath = archiveBasePath.concat(File.separator + apiIdentifier.getApiName() + "-" +
+ apiIdentifier.getVersion());
+ createDirectory(archivePath + File.separator + "Sequences");
+
+ String sequenceName;
+ String direction;
+ for (Map.Entry sequence : sequences.entrySet()) {
+ sequenceName = sequence.getValue();
+ direction = sequence.getKey();
+ AbstractMap.SimpleEntry sequenceDetails;
+ if (sequenceName != null) {
+ if (APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN.equalsIgnoreCase(direction)) {
+ sequenceDetails = getCustomSequence(sequenceName, APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN,
+ registry);
+ writeSequenceToFile(sequenceDetails, APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN,
+ apiIdentifier);
+ } else if (APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT.equalsIgnoreCase(direction)) {
+ sequenceDetails = getCustomSequence(sequenceName, APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT,
+ registry);
+ writeSequenceToFile(sequenceDetails, APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT,
+ apiIdentifier);
+ } else {
+ sequenceDetails = getCustomSequence(sequenceName,
+ APIConstants.API_CUSTOM_SEQUENCE_TYPE_FAULT, registry);
+ writeSequenceToFile(sequenceDetails, APIConstants.API_CUSTOM_SEQUENCE_TYPE_FAULT,
+ apiIdentifier);
+ }
+ }
+ }
+ }
+ }
+
+ /**
+ * Retrieve custom sequence details from the registry
+ *
+ * @param sequenceName Name of the sequence
+ * @param type Sequence type
+ * @param registry Current tenant registry
+ * @return Registry resource name of the sequence and its content
+ * @throws APIExportException If an error occurs while retrieving registry elements
+ */
+ private static AbstractMap.SimpleEntry getCustomSequence(String sequenceName,
+ String type, Registry registry) throws APIExportException {
+ AbstractMap.SimpleEntry sequenceDetails;
+
+ org.wso2.carbon.registry.api.Collection seqCollection = null;
+
+ try {
+ if (APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN.equals(type)) {
+ seqCollection =
+ (org.wso2.carbon.registry.api.Collection) registry.get(APIConstants.API_CUSTOM_INSEQUENCE_LOCATION);
+ }
+ else if (APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT.equals(type)) {
+ seqCollection =
+ (org.wso2.carbon.registry.api.Collection) registry.get(APIConstants.API_CUSTOM_OUTSEQUENCE_LOCATION);
+ }
+ else if(APIConstants.API_CUSTOM_SEQUENCE_TYPE_FAULT.equals(type)) {
+ seqCollection =
+ (org.wso2.carbon.registry.api.Collection) registry.get(APIConstants.API_CUSTOM_FAULTSEQUENCE_LOCATION);
+ }
+
+ if (seqCollection != null) {
+ String[] childPaths = seqCollection.getChildren();
+
+ for (int i = 0; i < childPaths.length; i++) {
+ Resource sequence = registry.get(childPaths[i]);
+ OMElement seqElment = APIUtil.buildOMElement(sequence.getContentStream());
+ if (sequenceName.equals(seqElment.getAttributeValue(new QName("name")))) {
+ String sequenceFileName = sequence.getPath().substring(sequence.getPath().lastIndexOf('/'));
+ sequenceDetails = new AbstractMap.SimpleEntry(sequenceFileName, seqElment);
+ return sequenceDetails;
+ }
+ }
+ }
+
+ } catch (RegistryException e) {
+ log.error("Error while retrieving sequence from the registry " + e.getMessage());
+ throw new APIExportException("Error while retrieving sequence from the registry", e);
+ } catch (Exception e ) { //APIUtil.buildOMElement() throws a generic exception
+ log.error("Error while reading sequence content " + e.getMessage());
+ throw new APIExportException("Error while reading sequence content", e);
+ }
+
+ return null;
+
+ }
+
+ /**
+ * Store custom sequences in the archive directory
+ *
+ * @param sequenceDetails Details of the sequence
+ * @param direction Direction of the sequence "in", "out" or "fault"
+ * @param apiIdentifier ID of the requesting API
+ * @throws APIExportException If an error occurs while serializing XML stream or storing in
+ * archive directory
+ */
+ private static void writeSequenceToFile(AbstractMap.SimpleEntry sequenceDetails, String direction,
+ APIIdentifier apiIdentifier) throws APIExportException {
+ OutputStream outputStream = null;
+ String archivePath = archiveBasePath.concat(File.separator + apiIdentifier.getApiName() + "-" +
+ apiIdentifier.getVersion()) + File.separator + "Sequences" + File.separator;
+
+ String pathToExportedSequence = archivePath + direction + "-sequence" + File.separator;
+ String sequenceFileName = sequenceDetails.getKey();
+ OMElement sequenceConfig = sequenceDetails.getValue();
+ String exportedSequenceFile = pathToExportedSequence + sequenceFileName;
+ try {
+ createDirectory(pathToExportedSequence);
+ outputStream = new FileOutputStream(exportedSequenceFile);
+ sequenceConfig.serialize(outputStream);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Sequence retrieved successfully");
+ }
+
+ } catch (FileNotFoundException e) {
+ log.error("Unable to find file" + e.getMessage());
+ throw new APIExportException("Unable to find file: " + exportedSequenceFile, e);
+ } catch (XMLStreamException e) {
+ log.error("Error while processing XML stream" + e.getMessage());
+ throw new APIExportException("Error while processing XML stream", e);
+ } finally {
+ IOUtils.closeQuietly(outputStream);
+ }
+ }
+
+ /**
+ * Create directory at the given path
+ *
+ * @param path Path of the directory
+ * @throws APIExportException If directory creation failed
+ */
+ public static void createDirectory(String path) throws APIExportException {
+ if (path != null) {
+ File file = new File(path);
+ if (!file.exists() && !file.mkdirs()) {
+ log.error("Error while creating directory : " + path);
+ throw new APIExportException("Directory creation failed " + path);
+ }
+ }
+ }
+
+ /**
+ * Retrieve meta information of the API to export
+ * URL template information are stored in swagger.json definition while rest of the required
+ * data are in api.json
+ *
+ * @param apiToReturn API to be exported
+ * @param registry Current tenant registry
+ * @throws APIExportException If an error occurs while exporting meta information
+ */
+ private static void exportMetaInformation(API apiToReturn, Registry registry) throws APIExportException {
+ APIDefinition definitionFromSwagger20 = new APIDefinitionFromSwagger20();
+ String archivePath = archiveBasePath.concat(File.separator + apiToReturn.getId().getApiName() + "-" +
+ apiToReturn.getId().getVersion());
+
+ createDirectory(archivePath + File.separator + "Meta-information");
+
+ Gson gson = new GsonBuilder().setPrettyPrinting().create();
+ String apiInJson = gson.toJson(apiToReturn);
+ writeFile(archivePath + File.separator + "Meta-information" + File.separator + "api.json", apiInJson);
+
+ try {
+ String swaggerDefinition = definitionFromSwagger20.getAPIDefinition(apiToReturn.getId(), registry);
+ JsonParser parser = new JsonParser();
+ JsonObject json = parser.parse(swaggerDefinition).getAsJsonObject();
+ String formattedSwaggerJson = gson.toJson(json);
+ writeFile(archivePath + File.separator + "Meta-information" + File.separator + "swagger.json",
+ formattedSwaggerJson);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Meta information retrieved successfully");
+ }
+
+ } catch (APIManagementException e) {
+ log.error("Error while retrieving Swagger definition" + e.getMessage());
+ throw new APIExportException("Error while retrieving Swagger definition", e);
+ }
+ }
+
+ /**
+ * Write content to file
+ *
+ * @param path Location of the file
+ * @param content Content to be written
+ * @throws APIExportException If an error occurs while writing to file
+ */
+ private static void writeFile(String path, String content) throws APIExportException {
+ FileWriter writer = null;
+
+ try {
+ writer = new FileWriter(path);
+ IOUtils.copy(new StringReader(content), writer);
+ } catch (IOException e) {
+ log.error("I/O error while writing to file" + e.getMessage());
+ throw new APIExportException("I/O error while writing to file", e);
+ } finally {
+ IOUtils.closeQuietly(writer);
+ }
+
+ }
+
+}
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIImportUtil.java b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIImportUtil.java
new file mode 100644
index 0000000000..d0850792b6
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/APIImportUtil.java
@@ -0,0 +1,562 @@
+/*
+ *
+ * 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 apim.restful.importexport.utils;
+
+import apim.restful.importexport.APIExportException;
+import apim.restful.importexport.APIImportExportConstants;
+import apim.restful.importexport.APIImportException;
+import apim.restful.importexport.APIService;
+
+import com.google.common.collect.Sets;
+import com.google.gson.Gson;
+
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.google.gson.JsonParser;
+import org.apache.axiom.om.OMElement;
+import org.apache.commons.io.FileUtils;
+import org.apache.commons.io.FilenameUtils;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import org.wso2.carbon.apimgt.api.APIManagementException;
+import org.wso2.carbon.apimgt.api.APIProvider;
+import org.wso2.carbon.apimgt.api.FaultGatewaysException;
+import org.wso2.carbon.apimgt.api.model.API;
+import org.wso2.carbon.apimgt.api.model.APIIdentifier;
+import org.wso2.carbon.apimgt.api.model.Documentation;
+import org.wso2.carbon.apimgt.api.model.Icon;
+import org.wso2.carbon.apimgt.api.model.Tier;
+import org.wso2.carbon.apimgt.impl.APIConstants;
+import org.wso2.carbon.apimgt.impl.utils.APIUtil;
+
+import org.wso2.carbon.registry.api.Registry;
+import org.wso2.carbon.registry.core.RegistryConstants;
+import org.wso2.carbon.registry.core.Resource;
+
+import javax.xml.namespace.QName;
+import java.io.BufferedInputStream;
+import java.io.BufferedReader;
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.InputStreamReader;
+import java.io.InputStream;
+import java.io.IOException;
+
+import java.net.MalformedURLException;
+import java.net.URL;
+import java.net.URLConnection;
+
+import java.util.Enumeration;
+import java.util.Set;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipFile;
+
+/**
+ * This class provides the functions utilized to import an API from an API archive.
+ */
+public final class APIImportUtil {
+
+ private static final Log log = LogFactory.getLog(APIService.class);
+ static APIProvider provider;
+
+ /**
+ * This method initializes the Provider when there is a direct request to import an API
+ *
+ * @param currentUserName the current logged in user
+ * @throws APIExportException if provider cannot be initialized
+ */
+ public static void initializeProvider(String currentUserName) throws APIExportException {
+ provider = APIExportUtil.getProvider(currentUserName);
+ }
+
+ /**
+ * This method uploads a given file to specified location
+ *
+ * @param uploadedInputStream input stream of the file
+ * @param newFileName name of the file to be created
+ * @param storageLocation destination of the new file
+ * @throws APIImportException if the file transfer fails
+ */
+ public static void transferFile(InputStream uploadedInputStream, String newFileName, String storageLocation)
+ throws APIImportException {
+ FileOutputStream outFileStream = null;
+
+ try {
+ outFileStream = new FileOutputStream(new File(storageLocation, newFileName));
+ int read = 0;
+ byte[] bytes = new byte[1024];
+ while ((read = uploadedInputStream.read(bytes)) != -1) {
+ outFileStream.write(bytes, 0, read);
+ }
+ } catch (IOException e) {
+ log.error("Error in transferring files.", e);
+ throw new APIImportException("Error in transferring archive files. " + e.getMessage());
+ } finally {
+ IOUtils.closeQuietly(outFileStream);
+ }
+ }
+
+ /**
+ * This method decompresses API the archive
+ *
+ * @param sourceFile The archive containing the API
+ * @param destination location of the archive to be extracted
+ * @return Name of the extracted directory
+ * @throws APIImportException If the decompressing fails
+ */
+ public static String extractArchive(File sourceFile, String destination) throws APIImportException {
+
+ BufferedInputStream inputStream = null;
+ InputStream zipInputStream = null;
+ FileOutputStream outputStream = null;
+ ZipFile zip = null;
+ String archiveName = null;
+
+ try {
+ zip = new ZipFile(sourceFile);
+ Enumeration zipFileEntries = zip.entries();
+ int index = 0;
+
+ // Process each entry
+ while (zipFileEntries.hasMoreElements()) {
+
+ // grab a zip file entry
+ ZipEntry entry = (ZipEntry) zipFileEntries.nextElement();
+ String currentEntry = entry.getName();
+
+ //This index variable is used to get the extracted folder name; that is root directory
+ if (index == 0) {
+ archiveName = currentEntry.substring(0, currentEntry.indexOf(File.separatorChar));
+ --index;
+ }
+
+ File destinationFile = new File(destination, currentEntry);
+ File destinationParent = destinationFile.getParentFile();
+
+ // create the parent directory structure
+ if (destinationParent.mkdirs()) {
+ log.info("Creation of folder is successful. Directory Name : " + destinationParent.getName());
+ }
+
+ if (!entry.isDirectory()) {
+ zipInputStream = zip.getInputStream(entry);
+ inputStream = new BufferedInputStream(zipInputStream);
+
+ // write the current file to the destination
+ outputStream = new FileOutputStream(destinationFile);
+ IOUtils.copy(inputStream, outputStream);
+ }
+ }
+ return archiveName;
+ } catch (IOException e) {
+ log.error("Failed to extract archive file ", e);
+ throw new APIImportException("Failed to extract archive file. " + e.getMessage());
+ } finally {
+ IOUtils.closeQuietly(zipInputStream);
+ IOUtils.closeQuietly(inputStream);
+ IOUtils.closeQuietly(outputStream);
+ }
+ }
+
+ /**
+ * This method imports an API
+ *
+ * @param pathToArchive location of the extracted folder of the API
+ * @param currentUser the current logged in user
+ * @param isDefaultProviderAllowed decision to keep or replace the provider
+ * @throws APIImportException if there is an error in importing an API
+ */
+ public static void importAPI(String pathToArchive, String currentUser, boolean isDefaultProviderAllowed)
+ throws APIImportException {
+
+ API importedApi;
+
+ // If the original provider is preserved,
+ if (isDefaultProviderAllowed) {
+
+ FileInputStream inputStream = null;
+ BufferedReader bufferedReader = null;
+
+ try {
+ inputStream = new FileInputStream(pathToArchive + APIImportExportConstants.JSON_FILE_LOCATION);
+ bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+ importedApi = new Gson().fromJson(bufferedReader, API.class);
+ } catch (FileNotFoundException e) {
+ log.error("Error in locating api.json file. ", e);
+ throw new APIImportException("Error in locating api.json file. " + e.getMessage());
+ } finally {
+ IOUtils.closeQuietly(inputStream);
+ IOUtils.closeQuietly(bufferedReader);
+ }
+ } else {
+
+ String pathToJSONFile = pathToArchive + APIImportExportConstants.JSON_FILE_LOCATION;
+
+ try {
+ String jsonContent = FileUtils.readFileToString(new File(pathToJSONFile));
+ JsonElement configElement = new JsonParser().parse(jsonContent);
+ JsonObject configObject = configElement.getAsJsonObject();
+
+ //locate the "providerName" within the "id" and set it as the current user
+ JsonObject apiId = configObject.getAsJsonObject(APIImportExportConstants.ID_ELEMENT);
+ apiId.addProperty(APIImportExportConstants.PROVIDER_ELEMENT, APIUtil.replaceEmailDomain(currentUser));
+ importedApi = new Gson().fromJson(configElement, API.class);
+
+ } catch (IOException e) {
+ log.error("Error in setting API provider to logged in user. ", e);
+ throw new APIImportException("Error in setting API provider to logged in user. " + e.getMessage());
+ }
+ }
+
+ Set allowedTiers;
+ Set unsupportedTiersList;
+
+ try{
+ allowedTiers = provider.getTiers();
+ } catch (APIManagementException e) {
+ log.error("Error in retrieving tiers of the provider. ", e);
+ throw new APIImportException("Error in retrieving tiers of the provider. " + e.getMessage());
+ }
+
+ if (!(allowedTiers.isEmpty())){
+ unsupportedTiersList = Sets.difference(importedApi.getAvailableTiers(), allowedTiers);
+
+ //If at least one unsupported tier is found, it should be removed before adding API
+ if (!(unsupportedTiersList.isEmpty())) {
+ for (Tier unsupportedTier : unsupportedTiersList) {
+
+ //Process is continued with a warning and only supported tiers are added to the importer API
+ log.warn("Tier name : " + unsupportedTier.getName() + " is not supported.");
+ }
+
+ //Remove the unsupported tiers before adding the API
+ importedApi.removeAvailableTiers(unsupportedTiersList);
+ }
+ }
+
+ try{
+ provider.addAPI(importedApi);
+ addSwaggerDefinition(importedApi.getId(), pathToArchive);
+ } catch (APIManagementException e){
+ //Error is logged and APIImportException is thrown because adding API and swagger are mandatory steps
+ log.error("Error in adding API to the provider. ", e);
+ throw new APIImportException("Error in adding API to the provider. " + e.getMessage());
+ }
+
+ //Since Image, documents, sequences and WSDL are optional, exceptions are logged and ignored in implementation
+ addAPIImage(pathToArchive, importedApi);
+ addAPIDocuments(pathToArchive, importedApi);
+ addAPISequences(pathToArchive, importedApi, currentUser);
+ addAPIWsdl(pathToArchive, importedApi, currentUser);
+
+ }
+
+ /**
+ * This method adds the icon to the API which is to be displayed at the API store.
+ *
+ * @param pathToArchive location of the extracted folder of the API
+ * @param importedApi the imported API object
+ */
+ private static void addAPIImage(String pathToArchive, API importedApi) {
+
+ //Adding image icon to the API if there is any
+ File imageFolder = new File(pathToArchive + APIImportExportConstants.IMAGE_FILE_LOCATION);
+ File[] fileArray = imageFolder.listFiles();
+ FileInputStream inputStream = null;
+
+ try {
+ if (imageFolder.isDirectory() && fileArray != null) {
+
+ //This loop locates the icon of the API
+ for (File imageFile : fileArray) {
+ if (imageFile != null && imageFile.getName().contains(APIImportExportConstants.IMAGE_FILE_NAME)) {
+
+ String mimeType = URLConnection.guessContentTypeFromName(imageFile.getName());
+ inputStream = new FileInputStream(imageFile.getAbsolutePath());
+ Icon apiImage = new Icon(inputStream, mimeType);
+ String thumbPath = APIUtil.getIconPath(importedApi.getId());
+ String thumbnailUrl = provider.addIcon(thumbPath, apiImage);
+
+ importedApi.setThumbnailUrl(APIUtil.prependTenantPrefix(thumbnailUrl,
+ importedApi.getId().getProviderName()));
+ APIUtil.setResourcePermissions(importedApi.getId().getProviderName(), null, null, thumbPath);
+ provider.updateAPI(importedApi);
+
+ //the loop is terminated after successfully locating the icon
+ break;
+ }
+ }
+ }
+ } catch (FileNotFoundException e) {
+ //This is logged and process is continued because icon is optional for an API
+ log.error("Icon for API is not found. ", e);
+ } catch (APIManagementException e){
+ //This is logged and process is continued because icon is optional for an API
+ log.error("Failed to add icon to the API. ", e);
+ } catch (FaultGatewaysException e) {
+ //This is logged and process is continued because icon is optional for an API
+ log.error("Failed to update API after adding icon. ", e);
+ } finally {
+ IOUtils.closeQuietly(inputStream);
+ }
+ }
+
+ /**
+ * This method adds the documents to the imported API
+ *
+ * @param pathToArchive location of the extracted folder of the API
+ * @param importedApi the imported API object
+ */
+ private static void addAPIDocuments(String pathToArchive, API importedApi) {
+
+ String docFileLocation = pathToArchive + APIImportExportConstants.DOCUMENT_FILE_LOCATION;
+ FileInputStream inputStream = null;
+ BufferedReader bufferedReader = null;
+ APIIdentifier apiIdentifier = importedApi.getId();
+
+ try {
+ if (checkFileExistence(docFileLocation)) {
+
+ inputStream = new FileInputStream(docFileLocation);
+ bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
+ Documentation[] documentations = new Gson().fromJson(bufferedReader, Documentation[].class);
+
+ //For each type of document separate action is performed
+ for (Documentation doc : documentations) {
+
+ if (APIImportExportConstants.INLINE_DOC_TYPE.equalsIgnoreCase(doc.getSourceType().toString())) {
+ provider.addDocumentation(apiIdentifier, doc);
+ provider.addDocumentationContent(importedApi, doc.getName(), doc.getSummary());
+
+ } else if (APIImportExportConstants.URL_DOC_TYPE.equalsIgnoreCase(doc.getSourceType().toString())) {
+ provider.addDocumentation(apiIdentifier, doc);
+
+ } else if (APIImportExportConstants.FILE_DOC_TYPE.
+ equalsIgnoreCase(doc.getSourceType().toString())) {
+ inputStream = new FileInputStream(pathToArchive + doc.getFilePath());
+ String docExtension = FilenameUtils.getExtension(pathToArchive + doc.getFilePath());
+ Icon apiDocument = new Icon(inputStream, docExtension);
+ String visibleRolesList = importedApi.getVisibleRoles();
+ String[] visibleRoles = new String[0];
+
+ if (visibleRolesList != null) {
+ visibleRoles = visibleRolesList.split(",");
+ }
+
+ String filePathDoc = APIUtil.getDocumentationFilePath(apiIdentifier, doc.getName());
+ APIUtil.setResourcePermissions(importedApi.getId().getProviderName(),
+ importedApi.getVisibility(), visibleRoles, filePathDoc);
+ doc.setFilePath(provider.addIcon(filePathDoc, apiDocument));
+ provider.addDocumentation(apiIdentifier, doc);
+ }
+ }
+ }
+ } catch (FileNotFoundException e) {
+ //this error is logged and ignored because documents are optional in an API
+ log.error("Failed to locate the document files of the API.", e);
+ } catch (APIManagementException e){
+ //this error is logged and ignored because documents are optional in an API
+ log.error("Failed to add Documentations to API.", e);
+ } finally {
+ IOUtils.closeQuietly(inputStream);
+ IOUtils.closeQuietly(bufferedReader);
+ }
+
+ }
+
+ /**
+ * This method adds API sequences to the imported API. If the sequence is a newly defined one, it is added.
+ *
+ * @param pathToArchive location of the extracted folder of the API
+ * @param importedApi the imported API object
+ * @param currentUser current logged in username
+ */
+ private static void addAPISequences(String pathToArchive, API importedApi, String currentUser) {
+
+ Registry registry = APIExportUtil.getRegistry(currentUser);
+ //Adding in-sequence, if any
+ String inSequenceName = importedApi.getInSequence();
+ if (inSequenceName != null && !inSequenceName.isEmpty()) {
+ importAPISequence(inSequenceName, registry, APIConstants.API_CUSTOM_SEQUENCE_TYPE_IN,pathToArchive,
+ APIImportExportConstants.IN_SEQUENCE_LOCATION);
+ }
+
+ //Adding out-sequence, if any
+ String outSequenceName = importedApi.getOutSequence();
+ if (outSequenceName != null && !outSequenceName.isEmpty()) {
+ importAPISequence(outSequenceName, registry, APIConstants.API_CUSTOM_SEQUENCE_TYPE_OUT,pathToArchive,
+ APIImportExportConstants.OUT_SEQUENCE_LOCATION);
+ }
+
+ //Adding fault-sequence, if any
+ String faultSequenceName = importedApi.getFaultSequence();
+ if (faultSequenceName != null && !faultSequenceName.isEmpty()) {
+ importAPISequence(faultSequenceName, registry, APIConstants.API_CUSTOM_SEQUENCE_TYPE_FAULT, pathToArchive,
+ APIImportExportConstants.FAULT_SEQUENCE_LOCATION);
+ }
+ }
+
+ /**
+ * Import custom sequences
+ *
+ * @param sequenceName Name of the sequence
+ * @param registry Tenant registry
+ * @param direction Direction of the sequence
+ * @param pathToArchive Location of the extracted folder of the imported APi archive
+ */
+ private static void importAPISequence(String sequenceName, Registry registry, String direction,
+ String pathToArchive, String sequenceLocation)
+ {
+ String sequenceFileLocation = pathToArchive + sequenceLocation;
+ File sequenceFileFolder = new File(sequenceFileLocation);
+ File[] fileList = sequenceFileFolder.listFiles();
+ String sequenceFileName;
+ InputStream fileInputStream = null;
+ for (final File fileEntry : fileList) {
+ if (fileEntry.isFile()) {
+ try {
+ fileInputStream = new FileInputStream(fileEntry);
+ OMElement seqElement = APIUtil.buildOMElement(fileInputStream);
+ if (sequenceName.equals(seqElement.getAttributeValue(new QName("name")))) {
+ sequenceFileName = FilenameUtils.getName(fileEntry.getName());
+ addSequenceToRegistry(registry, direction, sequenceFileName,
+ sequenceFileLocation + sequenceFileName);
+ }
+ } catch (Exception e) {
+ //this error is logged and ignored because sequences are optional in an API
+ log.error("Failed to retrieve Sequence of imported API.", e);
+ } finally {
+ IOUtils.closeQuietly(fileInputStream);
+ }
+ }
+ }
+ }
+
+ /**
+ * This method adds the sequence files to the registry.
+ *
+ * @param registry the registry instance
+ * @param customSequenceType type of the sequence
+ * @param sequenceFileName name of the sequence
+ * @param sequenceFileLocation location of the sequence file
+ */
+ private static void addSequenceToRegistry(Registry registry, String customSequenceType, String sequenceFileName,
+ String sequenceFileLocation) {
+
+ String regResourcePath = APIConstants.API_CUSTOM_SEQUENCE_LOCATION + RegistryConstants.PATH_SEPARATOR +
+ customSequenceType + RegistryConstants.PATH_SEPARATOR + sequenceFileName;
+ InputStream inSeqStream = null;
+ try {
+ if (registry.resourceExists(regResourcePath)) {
+ if (log.isDebugEnabled()) {
+ log.debug("Defined sequences have already been added to the registry");
+ }
+ } else {
+ if (log.isDebugEnabled()) {
+ log.debug("Adding defined sequences to the registry.");
+ }
+ File sequenceFile = new File(sequenceFileLocation);
+ inSeqStream = new FileInputStream(sequenceFile);
+ byte[] inSeqData = IOUtils.toByteArray(inSeqStream);
+ Resource inSeqResource = (Resource) registry.newResource();
+ inSeqResource.setContent(inSeqData);
+ registry.put(regResourcePath, inSeqResource);
+ }
+ } catch (org.wso2.carbon.registry.api.RegistryException e) {
+ //this is logged and ignored because sequences are optional
+ log.error("Failed to add sequences into the registry: " + customSequenceType, e);
+ } catch (IOException e) {
+ //this is logged and ignored because sequences are optional
+ log.error("I/O error while writing sequence data to the registry, Sequence type: " + customSequenceType, e);
+ } finally {
+ IOUtils.closeQuietly(inSeqStream);
+ }
+ }
+
+ /**
+ * This method adds the WSDL to the registry, if there is a WSDL associated with the API
+ *
+ * @param pathToArchive location of the extracted folder of the API
+ * @param importedApi the imported API object
+ * @param currentUser current logged in username
+ */
+ private static void addAPIWsdl(String pathToArchive, API importedApi, String currentUser) {
+
+ String wsdlFileName = importedApi.getId().getApiName() + "-" + importedApi.getId().getVersion() +
+ APIImportExportConstants.WSDL_EXTENSION;
+ String wsdlPath = pathToArchive + APIImportExportConstants.WSDL_LOCATION + wsdlFileName;
+
+ if (checkFileExistence(wsdlPath)) {
+ try {
+ URL wsdlFileUrl = new File(wsdlPath).toURI().toURL();
+ importedApi.setWsdlUrl(wsdlFileUrl.toString());
+ Registry registry = APIExportUtil.getRegistry(currentUser);
+ APIUtil.createWSDL((org.wso2.carbon.registry.core.Registry) registry, importedApi);
+ } catch (MalformedURLException e) {
+ //this exception is logged and ignored since WSDL is optional for an API
+ log.error("Error in getting WSDL URL. ", e);
+ } catch (org.wso2.carbon.registry.core.exceptions.RegistryException e) {
+ //this exception is logged and ignored since WSDL is optional for an API
+ log.error("Error in putting the WSDL resource to registry. ", e);
+ } catch (APIManagementException e) {
+ //this exception is logged and ignored since WSDL is optional for an API
+ log.error("Error in creating the WSDL resource in the registry. ", e);
+ }
+ }
+ }
+
+ /**
+ * This method adds Swagger API definition to registry
+ *
+ * @param apiId Identifier of the imported API
+ * @param archivePath File path where API archive stored
+ * @throws APIImportException if there is an error occurs when adding Swagger definition
+ */
+ private static void addSwaggerDefinition(APIIdentifier apiId, String archivePath)
+ throws APIImportException {
+
+ try {
+ String swaggerContent = FileUtils.readFileToString(
+ new File(archivePath + APIImportExportConstants.SWAGGER_DEFINITION_LOCATION));
+ provider.saveSwagger20Definition(apiId, swaggerContent);
+ } catch (APIManagementException e) {
+ log.error("Error in adding Swagger definition for the API. ", e);
+ throw new APIImportException("Error in adding Swagger definition for the API. " + e.getMessage());
+ } catch (IOException e) {
+ log.error("Error in importing Swagger definition for the API. ", e);
+ throw new APIImportException("Error in importing Swagger definition for the API. " + e.getMessage());
+ }
+ }
+
+ /**
+ * This method checks whether a given file exists in a given location
+ *
+ * @param fileLocation location of the file
+ * @return true if the file exists, false otherwise
+ */
+ private static boolean checkFileExistence(String fileLocation) {
+ File testFile = new File(fileLocation);
+ return testFile.exists();
+ }
+}
+
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/utils/ArchiveGeneratorUtil.java b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/ArchiveGeneratorUtil.java
new file mode 100644
index 0000000000..4ac18fdd57
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/ArchiveGeneratorUtil.java
@@ -0,0 +1,144 @@
+/*
+ *
+ * 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 apim.restful.importexport.utils;
+
+import apim.restful.importexport.APIExportException;
+import org.apache.commons.io.IOUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.zip.ZipEntry;
+import java.util.zip.ZipOutputStream;
+
+/**
+ * This class is used to generate zipped archive files
+ */
+public class ArchiveGeneratorUtil {
+ private static final Log log = LogFactory.getLog(ArchiveGeneratorUtil.class);
+
+ private ArchiveGeneratorUtil() {
+ }
+
+ /**
+ * Archive a provided source directory to a zipped file
+ *
+ * @param sourceDirectory Source directory
+ * @throws APIExportException If an error occurs while generating archive
+ */
+ public static void archiveDirectory(String sourceDirectory) throws APIExportException {
+
+ File directoryToZip = new File(sourceDirectory);
+
+ List fileList = new ArrayList();
+ getAllFiles(directoryToZip, fileList);
+ writeArchiveFile(directoryToZip, fileList);
+
+ if (log.isDebugEnabled()) {
+ log.debug("Archived API generated successfully");
+ }
+
+ }
+
+ /**
+ * Retrieve all the files included in the source directory to be archived
+ *
+ * @param sourceDirectory Source directory
+ * @param fileList List of files
+ */
+ private static void getAllFiles(File sourceDirectory, List fileList) {
+ File[] files = sourceDirectory.listFiles();
+ if (files != null) {
+ for (File file : files) {
+ fileList.add(file);
+ if (file.isDirectory()) {
+ getAllFiles(file, fileList);
+ }
+ }
+ }
+ }
+
+ /**
+ * Generate archive file
+ *
+ * @param directoryToZip Location of the archive
+ * @param fileList List of files to be included in the archive
+ * @throws APIExportException If an error occurs while adding files to the archive
+ */
+ private static void writeArchiveFile(File directoryToZip, List fileList) throws APIExportException {
+
+ FileOutputStream fileOutputStream = null;
+ ZipOutputStream zipOutputStream = null;
+
+ try {
+ fileOutputStream = new FileOutputStream(directoryToZip.getPath() + ".zip");
+ zipOutputStream = new ZipOutputStream(fileOutputStream);
+ for (File file : fileList) {
+ if (!file.isDirectory()) {
+ addToArchive(directoryToZip, file, zipOutputStream);
+ }
+ }
+
+ } catch (IOException e) {
+ log.error("I/O error while adding files to archive" + e.getMessage());
+ throw new APIExportException("I/O error while adding files to archive", e);
+ } finally {
+ IOUtils.closeQuietly(zipOutputStream);
+ IOUtils.closeQuietly(fileOutputStream);
+ }
+ }
+
+ /**
+ * Add files of the directory to the archive
+ *
+ * @param directoryToZip Location of the archive
+ * @param file File to be included in the archive
+ * @param zipOutputStream Output stream
+ * @throws APIExportException If an error occurs while writing files to the archive
+ */
+ private static void addToArchive(File directoryToZip, File file, ZipOutputStream zipOutputStream)
+ throws APIExportException {
+
+ FileInputStream fileInputStream = null;
+ try {
+ fileInputStream = new FileInputStream(file);
+
+ // Get relative path from archive directory to the specific file
+ String zipFilePath = file.getCanonicalPath()
+ .substring(directoryToZip.getCanonicalPath().length() + 1, file.getCanonicalPath().length());
+ ZipEntry zipEntry = new ZipEntry(zipFilePath);
+ zipOutputStream.putNextEntry(zipEntry);
+
+ IOUtils.copy(fileInputStream, zipOutputStream);
+
+ zipOutputStream.closeEntry();
+ } catch (IOException e) {
+ log.error("I/O error while writing files to archive" + e.getMessage());
+ throw new APIExportException("I/O error while writing files to archive", e);
+ } finally {
+ IOUtils.closeQuietly(fileInputStream);
+ }
+ }
+}
+
diff --git a/modules/api-import-export/src/main/java/apim/restful/importexport/utils/AuthenticatorUtil.java b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/AuthenticatorUtil.java
new file mode 100644
index 0000000000..dbde61b102
--- /dev/null
+++ b/modules/api-import-export/src/main/java/apim/restful/importexport/utils/AuthenticatorUtil.java
@@ -0,0 +1,170 @@
+/*
+ *
+ * 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 apim.restful.importexport.utils;
+
+import apim.restful.importexport.APIExportException;
+import org.apache.commons.codec.binary.Base64;
+import org.apache.commons.codec.binary.StringUtils;
+import org.apache.commons.logging.Log;
+import org.apache.commons.logging.LogFactory;
+import org.wso2.carbon.context.CarbonContext;
+import org.wso2.carbon.context.PrivilegedCarbonContext;
+import org.wso2.carbon.user.api.UserStoreException;
+import org.wso2.carbon.user.api.UserStoreManager;
+import org.wso2.carbon.utils.multitenancy.MultitenantUtils;
+
+import javax.ws.rs.core.HttpHeaders;
+import javax.ws.rs.core.MediaType;
+import javax.ws.rs.core.Response;
+import java.util.Arrays;
+import java.util.List;
+import java.util.StringTokenizer;
+
+/**
+ * This class provides authentication facility for importing and exporting APIs
+ * Basic authentication is used for this purpose
+ * Users with admin roles are only eligible for accessing those JAX-RS services
+ */
+public class AuthenticatorUtil {
+
+ private static final String AUTHORIZATION_PROPERTY = "Authorization";
+ private static final String AUTHENTICATION_SCHEME = "Basic";
+ private static final Log log = LogFactory.getLog(AuthenticatorUtil.class);
+ private static String username;
+ private static String password;
+
+ private AuthenticatorUtil() {
+ }
+
+ /**
+ * Checks whether received credentials for accessing API is authorized for exporting and
+ * importing APIs
+ *
+ * @param headers HTTP headers of the received request
+ * @return Response indicating whether authentication and authorization for accessing API got
+ * succeeded
+ * @throws APIExportException If an error occurs while authorizing current user
+ */
+
+ public static Response authorizeUser(HttpHeaders headers) throws APIExportException {
+ if (!isValidCredentials(headers)) {
+ log.error("No username and password is provided for authentication");
+ return Response.status(Response.Status.UNAUTHORIZED)
+ .entity("No username and password is provided for authentication").type(MediaType.APPLICATION_JSON).
+ build();
+
+ }
+
+ try {
+ String tenantDomain = MultitenantUtils.getTenantDomain(username);
+ PrivilegedCarbonContext.startTenantFlow();
+ PrivilegedCarbonContext.getThreadLocalCarbonContext().setTenantDomain(tenantDomain, true);
+
+ UserStoreManager userstoremanager =
+ CarbonContext.getThreadLocalCarbonContext().getUserRealm().getUserStoreManager();
+
+ String tenantAwareUsername = MultitenantUtils.getTenantAwareUsername(username);
+
+ //authenticate user provided credentials
+ if (userstoremanager.authenticate(tenantAwareUsername, password)) {
+ log.info(username + " user authenticated successfully");
+ //Get admin role name of the current domain
+ String adminRoleName =
+ CarbonContext.getCurrentContext().getUserRealm().getRealmConfiguration().getAdminRoleName();
+
+ String[] userRoles = userstoremanager.getRoleListOfUser(tenantAwareUsername);
+
+ //user is only authorized for exporting and importing if he is an admin of his
+ // domain
+ if (Arrays.asList(userRoles).contains(adminRoleName)) {
+ log.info(username + " is authorized to import and export APIs");
+ return Response.ok().build();
+ } else {
+ return Response.status(Response.Status.FORBIDDEN).entity("User Authorization " + "Failed")
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ } else {
+ return Response.status(Response.Status.UNAUTHORIZED).entity("User Authentication " + "Failed")
+ .type(MediaType.APPLICATION_JSON).build();
+ }
+
+ } catch (UserStoreException e) {
+ log.error("Error while accessing user configuration" + e.getMessage());
+ throw new APIExportException("Error while accessing user configuration", e);
+ } finally {
+ PrivilegedCarbonContext.endTenantFlow();
+ }
+
+ }
+
+ /**
+ * Checks whether user has provided non blank username and password for authentication
+ *
+ * @param headers Http Headers of the request
+ * @return boolean Whether a user name and password has been provided for authentication
+ * @throws APIExportException If an error occurs while extracting username and password from
+ * the header
+ */
+ private static boolean isValidCredentials(HttpHeaders headers) throws APIExportException {
+
+ //Fetch authorization header
+ final List authorization = headers.getRequestHeader(AUTHORIZATION_PROPERTY);
+
+ //If no authorization information present; block access
+ if (authorization == null || authorization.isEmpty()) {
+ return false;
+ }
+
+ //Get encoded username and password
+ final String encodedUserPassword = authorization.get(0).replaceFirst(AUTHENTICATION_SCHEME + " ", "");
+
+ //Decode username and password
+ String usernameAndPassword;
+ usernameAndPassword = StringUtils.newStringUtf8(Base64.decodeBase64(encodedUserPassword.getBytes()));
+
+ if (usernameAndPassword != null) {
+ //Split username and password tokens
+ final StringTokenizer tokenizer = new StringTokenizer(usernameAndPassword, ":");
+
+ if (tokenizer.hasMoreTokens()) {
+ username = tokenizer.nextToken();
+ }
+
+ if (tokenizer.hasMoreTokens()) {
+ password = tokenizer.nextToken();
+ }
+
+ if (username != null && password != null) {
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * Retrieve authenticated user name for the current session
+ *
+ * @return User name
+ */
+ public static String getAuthenticatedUserName() {
+ return username;
+ }
+}
diff --git a/modules/api-import-export/src/main/webapp/META-INF/MANIFEST.MF b/modules/api-import-export/src/main/webapp/META-INF/MANIFEST.MF
new file mode 100644
index 0000000000..274e1a9e53
--- /dev/null
+++ b/modules/api-import-export/src/main/webapp/META-INF/MANIFEST.MF
@@ -0,0 +1,12 @@
+Manifest-Version: 1.0
+Class-Path: cxf-rt-frontend-jaxrs-2.6.1.jar cxf-api-2.6.1.jar woodstox
+ -core-asl-4.1.2.jar stax2-api-3.1.1.jar xmlschema-core-2.0.2.jar gero
+ nimo-javamail_1.4_spec-1.7.1.jar wsdl4j-1.6.2.jar cxf-rt-core-2.6.1.j
+ ar jaxb-impl-2.1.13.jar jsr311-api-1.1.1.jar cxf-rt-bindings-xml-2.6.
+ 1.jar cxf-rt-transports-http-2.6.1.jar jackson-core-asl-1.8.6.jar jac
+ kson-mapper-asl-1.8.6.jar jackson-jaxrs-1.8.6.jar spring-web-3.0.6.RE
+ LEASE.jar aopalliance-1.0.jar spring-beans-3.0.6.RELEASE.jar spring-c
+ ore-3.0.6.RELEASE.jar spring-asm-3.0.6.RELEASE.jar commons-logging-1.
+ 1.1.jar spring-context-3.0.6.RELEASE.jar spring-aop-3.0.6.RELEASE.jar
+ spring-expression-3.0.6.RELEASE.jar
+
diff --git a/modules/api-import-export/src/main/webapp/META-INF/webapp-classloading.xml b/modules/api-import-export/src/main/webapp/META-INF/webapp-classloading.xml
new file mode 100644
index 0000000000..f9f4993fc3
--- /dev/null
+++ b/modules/api-import-export/src/main/webapp/META-INF/webapp-classloading.xml
@@ -0,0 +1,33 @@
+
+
+
+
+
+
+
+
+ false
+
+
+ CXF,Carbon
+
diff --git a/modules/api-import-export/src/main/webapp/WEB-INF/cxf-servlet.xml b/modules/api-import-export/src/main/webapp/WEB-INF/cxf-servlet.xml
new file mode 100644
index 0000000000..5dc831d4da
--- /dev/null
+++ b/modules/api-import-export/src/main/webapp/WEB-INF/cxf-servlet.xml
@@ -0,0 +1,36 @@
+
+
+
+
+
+
+
+
+