Java tutorial
/* * LinShare is an open source filesharing software, part of the LinPKI software * suite, developed by Linagora. * * Copyright (C) 2015-2016 LINAGORA * * This program is free software: you can redistribute it and/or modify it under * the terms of the GNU Affero General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version, provided you comply with the Additional Terms applicable for * LinShare software by Linagora pursuant to Section 7 of the GNU Affero General * Public License, subsections (b), (c), and (e), pursuant to which you must * notably (i) retain the display of the LinShare? trademark/logo at the top * of the interface window, the display of the You are using the Open Source * and free version of LinShare, powered by Linagora 20092015. Contribute to * Linshare R&D by subscribing to an Enterprise offer!? infobox and in the * e-mails sent with the Program, (ii) retain all hypertext links between * LinShare and linshare.org, between linagora.com and Linagora, and (iii) * refrain from infringing Linagora intellectual property rights over its * trademarks and commercial brands. Other Additional Terms apply, see * <http://www.linagora.com/licenses/> for more details. * * This program is distributed in the hope that it will be useful, but WITHOUT * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS * FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more * details. * * You should have received a copy of the GNU Affero General Public License and * its applicable Additional Terms for LinShare along with this program. If not, * see <http://www.gnu.org/licenses/> for the GNU Affero General Public License * version 3 and <http://www.linagora.com/licenses/> for the Additional Terms * applicable to LinShare software. */ package org.linagora.linshare.webservice.userv2.impl; import java.io.File; import java.io.InputStream; import java.nio.ByteBuffer; import java.nio.channels.FileChannel; import java.nio.file.Files; import java.nio.file.StandardOpenOption; import java.util.Date; import java.util.concurrent.ConcurrentMap; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.QueryParam; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import org.apache.commons.io.IOUtils; import org.apache.commons.io.output.ByteArrayOutputStream; import org.apache.commons.lang.Validate; import org.apache.cxf.jaxrs.ext.multipart.Multipart; import org.apache.cxf.jaxrs.ext.multipart.MultipartBody; import org.linagora.linshare.core.domain.constants.AsyncTaskType; import org.linagora.linshare.core.domain.objects.ChunkedFile; import org.linagora.linshare.core.exception.BusinessErrorCode; import org.linagora.linshare.core.exception.BusinessException; import org.linagora.linshare.core.facade.webservice.common.dto.AccountDto; import org.linagora.linshare.core.facade.webservice.common.dto.AsyncTaskDto; import org.linagora.linshare.core.facade.webservice.common.dto.EntryDto; import org.linagora.linshare.core.facade.webservice.common.dto.FlowDto; import org.linagora.linshare.core.facade.webservice.user.AccountQuotaFacade; import org.linagora.linshare.core.facade.webservice.user.AsyncTaskFacade; import org.linagora.linshare.core.facade.webservice.user.DocumentAsyncFacade; import org.linagora.linshare.core.facade.webservice.user.DocumentFacade; import org.linagora.linshare.core.facade.webservice.user.ThreadEntryAsyncFacade; import org.linagora.linshare.core.facade.webservice.user.WorkGroupEntryFacade; import org.linagora.linshare.webservice.WebserviceBase; import org.linagora.linshare.webservice.userv1.task.DocumentUploadAsyncTask; import org.linagora.linshare.webservice.userv1.task.ThreadEntryUploadAsyncTask; import org.linagora.linshare.webservice.userv1.task.context.DocumentTaskContext; import org.linagora.linshare.webservice.userv1.task.context.ThreadEntryTaskContext; import org.linagora.linshare.webservice.userv2.FlowDocumentUploaderRestService; import org.linagora.linshare.webservice.utils.FlowUploaderUtils; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import com.google.common.base.Strings; import com.google.common.collect.Maps; import com.wordnik.swagger.annotations.Api; import com.wordnik.swagger.annotations.ApiParam; @Path("/flow") @Api(value = "/rest/user/v2/flow", basePath = "/rest/user/v2/", description = "Flow Upload Documents service", produces = "application/json,application/xml", consumes = "application/json,application/xml") public class FlowDocumentUploaderRestServiceImpl extends WebserviceBase implements FlowDocumentUploaderRestService { private static final Logger logger = LoggerFactory.getLogger(FlowDocumentUploaderRestService.class); private static final String CHUNK_NUMBER = "flowChunkNumber"; private static final String TOTAL_CHUNKS = "flowTotalChunks"; private static final String CHUNK_SIZE = "flowChunkSize"; private static final String CURRENT_CHUNK_SIZE = "flowCurrentChunkSize"; private static final String TOTAL_SIZE = "flowTotalSize"; private static final String IDENTIFIER = "flowIdentifier"; private static final String FILENAME = "flowFilename"; private static final String RELATIVE_PATH = "flowRelativePath"; private static final String FILE = "file"; // TODO: refatoring name private static final String WORK_GROUP_UUID = "threadUuid"; private static final String WORK_GROUP_FOLDER_UUID = "workGroupFolderUuid"; private static final String ASYNC_TASK = "asyncTask"; private boolean sizeValidation; private final DocumentFacade documentFacade; private final WorkGroupEntryFacade threadEntryFacade; private final AccountQuotaFacade accountQuotaFacade; private static final ConcurrentMap<String, ChunkedFile> chunkedFiles = Maps.newConcurrentMap(); private final DocumentAsyncFacade documentAsyncFacade; private final ThreadEntryAsyncFacade threadEntryAsyncFacade; private final AsyncTaskFacade asyncTaskFacade; private org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor taskExecutor; public FlowDocumentUploaderRestServiceImpl(DocumentFacade documentFacade, WorkGroupEntryFacade workGroupEntryFacade, AccountQuotaFacade accountQuotaFacade, DocumentAsyncFacade documentAsyncFacade, ThreadEntryAsyncFacade threadEntryAsyncFacade, AsyncTaskFacade asyncTaskFacade, org.springframework.scheduling.concurrent.ThreadPoolTaskExecutor taskExecutor, boolean sizeValidation) { super(); this.documentFacade = documentFacade; this.sizeValidation = sizeValidation; this.threadEntryFacade = workGroupEntryFacade; this.accountQuotaFacade = accountQuotaFacade; this.documentAsyncFacade = documentAsyncFacade; this.threadEntryAsyncFacade = threadEntryAsyncFacade; this.asyncTaskFacade = asyncTaskFacade; this.taskExecutor = taskExecutor; } @Path("/") @POST @Consumes("multipart/form-data") @Override public FlowDto uploadChunk(@Multipart(CHUNK_NUMBER) long chunkNumber, @Multipart(TOTAL_CHUNKS) long totalChunks, @Multipart(CHUNK_SIZE) long chunkSize, @Multipart(CURRENT_CHUNK_SIZE) long currentChunkSize, @Multipart(TOTAL_SIZE) long totalSize, @Multipart(IDENTIFIER) String identifier, @Multipart(FILENAME) String filename, @Multipart(RELATIVE_PATH) String relativePath, @Multipart(FILE) InputStream file, MultipartBody body, @Multipart(value = WORK_GROUP_UUID, required = false) String workGroupUuid, @Multipart(value = WORK_GROUP_FOLDER_UUID, required = false) String workGroupFolderUuid, @Multipart(value = ASYNC_TASK, required = false) boolean async) throws BusinessException { logger.debug("upload chunk number : " + chunkNumber); identifier = cleanIdentifier(identifier); boolean isValid = FlowUploaderUtils.isValid(chunkNumber, chunkSize, totalSize, identifier, filename); Validate.isTrue(isValid); checkIfMaintenanceIsEnabled(); FlowDto flow = new FlowDto(chunkNumber); try { logger.debug("writing chunk number : " + chunkNumber); java.nio.file.Path tempFile = FlowUploaderUtils.getTempFile(identifier, chunkedFiles); ChunkedFile currentChunkedFile = chunkedFiles.get(identifier); if (!currentChunkedFile.hasChunk(chunkNumber)) { FileChannel fc = FileChannel.open(tempFile, StandardOpenOption.CREATE, StandardOpenOption.APPEND); ByteArrayOutputStream output = new ByteArrayOutputStream(); IOUtils.copy(file, output); fc.write(ByteBuffer.wrap(output.toByteArray()), (chunkNumber - 1) * chunkSize); fc.close(); if (sizeValidation) { if (output.size() != currentChunkSize) { String msg = String.format("File size does not match, found : %1$d, announced : %2$d", output.size(), currentChunkSize); logger.error(msg); flow.setChunkUploadSuccess(false); flow.setErrorMessage(msg); return flow; } } currentChunkedFile.addChunk(chunkNumber); } else { logger.error("currentChunkedFile.hasChunk(chunkNumber) !!! " + currentChunkedFile); logger.error("chunkedNumber skipped : " + chunkNumber); } logger.debug("nb uploading files : " + chunkedFiles.size()); logger.debug("current chuckedfile uuid : " + identifier); logger.debug("current chuckedfiles" + chunkedFiles.toString()); if (FlowUploaderUtils.isUploadFinished(identifier, chunkSize, totalSize, chunkedFiles)) { flow.setLastChunk(true); logger.debug("upload finished : " + chunkNumber + " : " + identifier); InputStream inputStream = Files.newInputStream(tempFile, StandardOpenOption.READ); File tempFile2 = getTempFile(inputStream, "rest-flowuploader", filename); if (sizeValidation) { long currSize = tempFile2.length(); if (currSize != totalSize) { String msg = String.format("File size does not match, found : %1$d, announced : %2$d", currSize, totalSize); logger.error(msg); flow.setChunkUploadSuccess(false); flow.setErrorMessage(msg); return flow; } } EntryDto uploadedDocument = new EntryDto(); flow.setIsAsync(async); boolean isWorkGroup = !Strings.isNullOrEmpty(workGroupUuid); if (async) { logger.debug("Async mode is used"); // Asynchronous mode AccountDto actorDto = documentFacade.getAuthenticatedAccountDto(); AsyncTaskDto asyncTask = null; try { if (isWorkGroup) { ThreadEntryTaskContext threadEntryTaskContext = new ThreadEntryTaskContext(actorDto, actorDto.getUuid(), workGroupUuid, tempFile2, filename, workGroupFolderUuid); asyncTask = asyncTaskFacade.create(totalSize, getTransfertDuration(identifier), filename, null, AsyncTaskType.THREAD_ENTRY_UPLOAD); ThreadEntryUploadAsyncTask task = new ThreadEntryUploadAsyncTask(threadEntryAsyncFacade, threadEntryTaskContext, asyncTask); taskExecutor.execute(task); flow.completeAsyncTransfert(asyncTask); } else { DocumentTaskContext documentTaskContext = new DocumentTaskContext(actorDto, actorDto.getUuid(), tempFile2, filename, null, null); asyncTask = asyncTaskFacade.create(totalSize, getTransfertDuration(identifier), filename, null, AsyncTaskType.DOCUMENT_UPLOAD); DocumentUploadAsyncTask task = new DocumentUploadAsyncTask(documentAsyncFacade, documentTaskContext, asyncTask); taskExecutor.execute(task); flow.completeAsyncTransfert(asyncTask); } } catch (Exception e) { logAsyncFailure(asyncTask, e); deleteTempFile(tempFile2); ChunkedFile remove = chunkedFiles.remove(identifier); Files.deleteIfExists(remove.getPath()); throw e; } } else { try { if (isWorkGroup) { uploadedDocument = threadEntryFacade.create(null, workGroupUuid, workGroupFolderUuid, tempFile2, filename); } else { uploadedDocument = documentFacade.create(tempFile2, filename, "", null); } flow.completeTransfert(uploadedDocument); } finally { deleteTempFile(tempFile2); ChunkedFile remove = chunkedFiles.remove(identifier); if (remove != null) { Files.deleteIfExists(remove.getPath()); } else { logger.error("Should not happen !!!"); logger.error("chunk number: " + chunkNumber); logger.error("chunk identifier: " + identifier); logger.error("chunk filename: " + filename); logger.error("chunks : " + chunkedFiles.toString()); } } } return flow; } else { logger.debug("upload pending "); flow.setChunkUploadSuccess(true); } } catch (BusinessException e) { logger.error(e.getMessage()); logger.debug("Exception : ", e); flow.setChunkUploadSuccess(false); flow.setErrorMessage(e.getMessage()); flow.setErrCode(e.getErrorCode().getCode()); } catch (Exception e) { logger.error(e.getMessage()); logger.debug("Exception : ", e); flow.setChunkUploadSuccess(false); flow.setErrorMessage(e.getMessage()); } return flow; } @Path("/") @GET @Override public Response testChunk(@QueryParam(CHUNK_NUMBER) long chunkNumber, @QueryParam(TOTAL_CHUNKS) long totalChunks, @QueryParam(CHUNK_SIZE) long chunkSize, @QueryParam(TOTAL_SIZE) long totalSize, @QueryParam(IDENTIFIER) String identifier, @QueryParam(FILENAME) String filename, @QueryParam(RELATIVE_PATH) String relativePath) { boolean maintenance = accountQuotaFacade.maintenanceModeIsEnabled(); Response testChunk = FlowUploaderUtils.testChunk(chunkNumber, totalChunks, chunkSize, totalSize, identifier, filename, relativePath, chunkedFiles, maintenance); if (chunkNumber == 1 || (chunkNumber % 20) == 0 || chunkNumber == totalChunks) { logger.info(String.format("GET: .../webservice/rest/user/v2/flow.json:%s: chunkNumber:%s/%s", identifier, chunkNumber, totalChunks)); } return testChunk; } @Path("/{uuid}") @GET @Produces({ MediaType.APPLICATION_XML, MediaType.APPLICATION_JSON }) @Override public AsyncTaskDto findAsync( @ApiParam(value = "Get the async task created at the end of an upload.", required = true) @PathParam("uuid") String uuid) throws BusinessException { Validate.notEmpty(uuid, "Missing uuid"); return asyncTaskFacade.find(uuid); } /** * HELPERS */ private String cleanIdentifier(String identifier) { return identifier.replaceAll("[^0-9A-Za-z_-]", ""); } private long getTransfertDuration(String identifier) { Date endDate = new Date(); long uploadStartTime = chunkedFiles.get(identifier).getStartTime(); long transfertDuration = endDate.getTime() - uploadStartTime; if (logger.isDebugEnabled()) { Date beginDate = new Date(uploadStartTime); logger.debug("Upload was begining at : " + beginDate); logger.debug("Upload was ending at : " + endDate); } logger.info("statistics:upload time:" + transfertDuration + "ms."); return transfertDuration; } private void checkIfMaintenanceIsEnabled() { boolean maintenance = accountQuotaFacade.maintenanceModeIsEnabled(); if (maintenance) { // Http error 501 throw new BusinessException(BusinessErrorCode.MODE_MAINTENANCE_ENABLED, "Maintenance mode is enable for this user. Uploads are disabled."); } } protected void logAsyncFailure(AsyncTaskDto asyncTask, Exception e) { logger.error(e.getMessage()); logger.debug("Exception : ", e); if (asyncTask != null) { asyncTaskFacade.fail(asyncTask, e); } } }