package chat.upload;
|
|
import java.io.File;
|
import java.io.RandomAccessFile;
|
import java.text.SimpleDateFormat;
|
import java.util.Date;
|
|
import org.slf4j.Logger;
|
import org.slf4j.LoggerFactory;
|
|
import chat.security.DES;
|
|
import chat.server.im.ResultPool;
|
import io.netty.buffer.ByteBuf;
|
import io.netty.handler.codec.http.FullHttpRequest;
|
import io.netty.handler.codec.http.HttpContent;
|
import io.netty.handler.codec.http.HttpHeaders;
|
import io.netty.handler.codec.http.multipart.Attribute;
|
import io.netty.handler.codec.http.multipart.DefaultHttpDataFactory;
|
import io.netty.handler.codec.http.multipart.FileUpload;
|
import io.netty.handler.codec.http.multipart.HttpDataFactory;
|
import io.netty.handler.codec.http.multipart.HttpPostRequestDecoder;
|
import io.netty.handler.codec.http.multipart.InterfaceHttpData;
|
import io.netty.util.internal.StringUtil;
|
|
public class UploadFile {
|
|
private static final String KEY = "imfile";
|
private static final Logger logger = LoggerFactory.getLogger(UploadFile.class);
|
private static final HttpDataFactory factory = new DefaultHttpDataFactory(false);
|
|
public static String multipartUpload(FullHttpRequest request, String requestId) {
|
HttpPostRequestDecoder decoder = null;
|
String key = "";
|
try {
|
decoder = new HttpPostRequestDecoder(factory, request);
|
} catch (Exception e) {
|
logger.error("Failed to decode file data!", e);
|
e.printStackTrace();
|
return "";
|
}
|
|
if (decoder != null) {
|
if (request instanceof HttpContent) {
|
HttpContent chunk = (HttpContent) request;
|
try {
|
decoder.offer(chunk);
|
} catch (Exception e) {
|
e.printStackTrace();
|
return "";
|
}
|
|
long fileTotalSize = 0;
|
if (request.headers().contains("X-File-Total-Size")) {
|
try {
|
fileTotalSize = Integer.parseInt(request.headers().get("X-File-Total-Size"));
|
} catch (Exception e) {
|
logger.warn("invalid X-File-Total-Size value!");
|
}
|
}
|
|
UploadFile uploadFile = new UploadFile();
|
key = uploadFile.readHttpDataChunkByChunk(decoder, requestId, HttpHeaders.isKeepAlive(request));
|
}
|
}
|
return key;
|
}
|
|
private String readHttpDataChunkByChunk(HttpPostRequestDecoder decoder, String requestId, boolean isKeepAlive) {
|
String returnValue = "";
|
try {
|
int[] bucket = new int[1];
|
bucket[0] = -1;
|
while (decoder.hasNext()) {
|
InterfaceHttpData data = decoder.next();
|
if (data != null) {
|
try {
|
returnValue = writeFileUploadData(data, requestId, isKeepAlive, bucket);
|
if (returnValue == null) {
|
break;
|
}
|
} finally {
|
data.release();
|
}
|
}
|
}
|
} catch(Exception e) {
|
logger.info("chunk end");
|
return returnValue;
|
//e.printStackTrace();
|
}
|
return returnValue;
|
}
|
|
private String writeFileUploadData(InterfaceHttpData data, String requestId, boolean isKeepAlive, int[] bucket) {
|
String relativePath = "";
|
try {
|
if (data.getHttpDataType() == InterfaceHttpData.HttpDataType.FileUpload) {
|
FileUpload fileUpload = (FileUpload) data;
|
|
String remoteFileName = fileUpload.getFilename();
|
long remoteFileSize = fileUpload.length();
|
|
if(bucket[0] == -1) {
|
logger.info("Not authenticated!");
|
return null;
|
}
|
|
if (StringUtil.isNullOrEmpty(remoteFileName)) {
|
logger.info("remoteFileName is empty!");
|
return null;
|
}
|
|
if (StringUtil.isNullOrEmpty(requestId)) {
|
logger.info("requestId is empty!");
|
return null;
|
}
|
|
if (remoteFileSize > 100 * 1024 * 1024) {
|
logger.info("file over limit!(" + remoteFileSize + ")");
|
return null;
|
}
|
|
String remoteFileExt = "";
|
if (remoteFileName.lastIndexOf(".") == -1) {
|
remoteFileExt = "octetstream";
|
remoteFileName = remoteFileName + "." + remoteFileExt;
|
|
} else {
|
remoteFileExt = getFileExt(remoteFileName);
|
}
|
|
if (StringUtil.isNullOrEmpty(remoteFileExt) || remoteFileExt.equals("ing")) {
|
logger.info("Invalid file extention name");
|
return null;
|
}
|
|
int remoteFileTotalSize = (int) remoteFileSize;
|
|
ByteBuf byteBuf = null;
|
int savedThunkSize = 0;
|
int offset = 0;
|
|
Date nowTime = new Date();
|
SimpleDateFormat sdf = new SimpleDateFormat("yyyy/MM/dd/HH");
|
String datePath = sdf.format(nowTime);
|
|
datePath = "fs/" + bucket[0] + "/" + datePath;
|
String dir = "D:/media/" + datePath;
|
|
File dirFile = new File(dir);
|
if (!dirFile.exists()) {
|
if (!dirFile.mkdirs()) {
|
logger.info("无法创建文件");
|
return null;
|
}
|
}
|
|
String filePath = dir + "/" + (StringUtil.isNullOrEmpty(remoteFileName) ? requestId : remoteFileName);
|
|
File tmpFile = new File(filePath);
|
|
boolean isError = false;
|
|
while (true) {
|
byte[] thunkData;
|
try {
|
byteBuf = fileUpload.getChunk(128 * 1024);
|
int readableBytesSize = byteBuf.readableBytes();
|
thunkData = new byte[readableBytesSize];
|
byteBuf.readBytes(thunkData);
|
|
put(tmpFile, offset, thunkData);
|
|
savedThunkSize += readableBytesSize;
|
offset += readableBytesSize;
|
|
if (savedThunkSize >= remoteFileSize) {
|
byteBuf.release();
|
fileUpload.release();
|
|
relativePath = datePath + "/" + (StringUtil.isNullOrEmpty(remoteFileName) ? requestId : remoteFileName);
|
|
break;
|
}
|
} catch(Exception e) {
|
logger.info("save thunckData error!");
|
if (fileUpload != null) {
|
fileUpload.release();
|
}
|
|
if (byteBuf != null) {
|
byteBuf.release();
|
}
|
isError = true;
|
|
return null;
|
} finally {
|
thunkData = null;
|
if (isError) {
|
tmpFile.delete();
|
}
|
}
|
}
|
}
|
else if (data.getHttpDataType() == InterfaceHttpData.HttpDataType.Attribute) {
|
Attribute attribute = (Attribute) data;
|
if (attribute.getName().equals("token")) {
|
String token = attribute.getValue();
|
|
try {
|
bucket[0] = validateToken(token);
|
relativePath = "";
|
} catch(Exception e) {
|
logger.info("无效的token!");
|
return null;
|
}
|
}
|
}
|
} catch(Exception e) {
|
logger.info("writeHttpData error!", e);
|
return null;
|
}
|
return relativePath;
|
}
|
|
public String getFileExt(String fileName) {
|
int index = fileName.lastIndexOf(".");
|
if (index == -1) {
|
return "";
|
}
|
|
return fileName.substring(index + 1).toLowerCase();
|
}
|
|
public void put(File file, long pos, byte[] data) throws Exception {
|
RandomAccessFile raf = null;
|
try {
|
raf = new RandomAccessFile(file, "rwd");
|
raf.seek(pos);
|
raf.write(data);
|
} finally {
|
try {
|
if (raf != null) {
|
raf.close();
|
}
|
} catch (Exception e) {
|
logger.info("release error!");
|
e.printStackTrace();
|
}
|
}
|
}
|
|
public int validateToken(String token) throws InvalidateTokenExecption {
|
try {
|
String signKey = DES.decryptDES(token);
|
String[] parts = signKey.split("\\|");
|
if(parts.length == 3) {
|
if(parts[0].equals(KEY)) {
|
long timestamp = Long.parseLong(parts[1]);
|
if(Math.abs(System.currentTimeMillis() - timestamp) < 2 * 60 * 60 * 1000) {
|
return Integer.parseInt(parts[2]);
|
}
|
}
|
}
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
throw new InvalidateTokenExecption();
|
}
|
|
public static class InvalidateTokenExecption extends Exception {}
|
|
}
|
