/**
* 全局设定文件
*
* @author xiaoleilu
*/
public class ServerSetting {
private static Logger log = Log.get();
// -------------------------------------------------------- Default value start
/** 默认的字符集编码 */
public static final String DEFAULT_CHARSET = "utf-8";
public static final String WILD_CARD = "/*";
// -------------------------------------------------------- Default value end
/** 字符编码 */
private static String charset = DEFAULT_CHARSET;
/** 端口 */
private static int port = 8090;
/** 根目录 */
private static File root;
/** Filter映射表 */
private static Map<String, Filter> filterMap;
/** Action映射表 */
private static Map<String, Action> actionMap;
static {
filterMap = new ConcurrentHashMap<String, Filter>();
actionMap = new ConcurrentHashMap<String, Action>();
final DefaultIndexAction defaultIndexAction = new DefaultIndexAction();
actionMap.put(StrUtil.SLASH, defaultIndexAction);
}
/** @return 获取编码 */
public static String getCharset() {
return charset;
}
/** @return 字符集 */
public static Charset charset() {
return Charset.forName(getCharset());
}
/**
* 设置编码
*
* @param charset 编码
*/
public static void setCharset(String charset) {
ServerSetting.charset = charset;
}
/** @return 监听端口 */
public static int getPort() {
return port;
}
/**
* 设置监听端口
*
* @param port 端口
*/
public static void setPort(int port) {
ServerSetting.port = port;
}
// -----------------------------------------------------------------------------------------------
// Root start
/** @return 根目录 */
public static File getRoot() {
return root;
}
/** @return 根目录 */
public static boolean isRootAvailable() {
if (root != null && root.isDirectory() && root.isHidden() == false && root.canRead()) {
return true;
}
return false;
}
/** @return 根目录 */
public static String getRootPath() {
return FileUtil.getAbsolutePath(root);
}
/**
* 根目录
*
* @param root 根目录绝对路径
*/
public static void setRoot(String root) {
ServerSetting.root = FileUtil.mkdir(root);
log.debug("Set root to [{}]", ServerSetting.root.getAbsolutePath());
}
/**
* 根目录
*
* @param root 根目录绝对路径
*/
public static void setRoot(File root) {
if (root.exists() == false) {
root.mkdirs();
} else if (root.isDirectory() == false) {
throw new ServerSettingException(StrUtil.format("{} is not a directory!", root.getPath()));
}
ServerSetting.root = root;
}
// -----------------------------------------------------------------------------------------------
// Root end
// -----------------------------------------------------------------------------------------------
// Filter start
/** @return 获取FilterMap */
public static Map<String, Filter> getFilterMap() {
return filterMap;
}
/**
* 获得路径对应的Filter
*
* @param path 路径，为空时将获得 根目录对应的Action
* @return Filter
*/
public static Filter getFilter(String path) {
if (StrUtil.isBlank(path)) {
path = StrUtil.SLASH;
}
return getFilterMap().get(path.trim());
}
/**
* 设置FilterMap
*
* @param filterMap FilterMap
*/
public static void setFilterMap(Map<String, Filter> filterMap) {
ServerSetting.filterMap = filterMap;
}
/**
* 设置Filter类，已有的Filter类将被覆盖
*
* @param path 拦截路径（必须以"/"开头）
* @param filter Action类
*/
public static void setFilter(String path, Filter filter) {
if (StrUtil.isBlank(path)) {
path = StrUtil.SLASH;
}
if (null == filter) {
log.warn("Added blank action, pass it.");
return;
}
// 所有路径必须以 "/" 开头，如果没有则补全之
if (false == path.startsWith(StrUtil.SLASH)) {
path = StrUtil.SLASH + path;
}
ServerSetting.filterMap.put(path, filter);
}
/**
* 设置Filter类，已有的Filter类将被覆盖
*
* @param path 拦截路径（必须以"/"开头）
* @param filterClass Filter类
*/
public static void setFilter(String path, Class<? extends Filter> filterClass) {
setFilter(path, (Filter) Singleton.get(filterClass));
}
/**
* 设置通配Filter类，已有的Filter类将被覆盖
*
* @param filter Action类
*/
public static void setWildCardFilter(Filter filter) {
setFilter(WILD_CARD, filter);
}
/**
* 设置通配Filter类，已有的Filter类将被覆盖
*
* @param filterClass Filter类
*/
public static void setWildCardFilter(Class<? extends Filter> filterClass) {
setWildCardFilter((Filter) Singleton.get(filterClass));
}
/** @return 获得通配路径对应的Filter */
public static Filter getWildCardFilter() {
return getFilter(WILD_CARD);
}
// -----------------------------------------------------------------------------------------------
// Filter end
// -----------------------------------------------------------------------------------------------
// Action start
/** @return 获取ActionMap */
public static Map<String, Action> getActionMap() {
return actionMap;
}
/**
* 获得路径对应的Action
*
* @param path 路径，为空时将获得 根目录对应的Action
* @return Action
*/
public static Action getAction(String path) {
if (StrUtil.isBlank(path)) {
path = StrUtil.SLASH;
}
return getActionMap().get(path.trim());
}
/**
* 设置ActionMap
*
* @param actionMap ActionMap
*/
public static void setActionMap(Map<String, Action> actionMap) {
ServerSetting.actionMap = actionMap;
}
/**
* 设置Action类，已有的Action类将被覆盖
*
* @param path 拦截路径（必须以"/"开头）
* @param action Action类
*/
public static void setAction(String path, Action action) {
if (StrUtil.isBlank(path)) {
path = StrUtil.SLASH;
}
if (null == action) {
log.warn("Added blank action, pass it.");
return;
}
// 所有路径必须以 "/" 开头，如果没有则补全之
if (false == path.startsWith(StrUtil.SLASH)) {
path = StrUtil.SLASH + path;
}
ServerSetting.actionMap.put(path, action);
}
/**
* 增加Action类，已有的Action类将被覆盖<br>
* 所有Action都是以单例模式存在的！
*
* @param path 拦截路径（必须以"/"开头）
* @param actionClass Action类
*/
public static void setAction(String path, Class<? extends Action> actionClass) {
setAction(path, (Action) Singleton.get(actionClass));
}
/**
* 增加Action类，已有的Action类将被覆盖<br>
* 自动读取Route的注解来获得Path路径
*
* @param action 带注解的Action对象
*/
public static void setAction(Action action) {
final Route route = action.getClass().getAnnotation(Route.class);
if (route != null) {
final String path = route.value();
if (StrUtil.isNotBlank(path)) {
setAction(path, action);
return;
}
}
throw new ServerSettingException(
"Can not find Route annotation,please add annotation to Action class!");
}
/**
* 增加Action类，已有的Action类将被覆盖<br>
* 所有Action都是以单例模式存在的！
*
* @param actionClass 带注解的Action类
*/
public static void setAction(Class<? extends Action> actionClass) {
setAction((Action) Singleton.get(actionClass));
}
// -----------------------------------------------------------------------------------------------
// Action start
}
/**
* 认证器
*
* @author Looly
*/
public class Auth implements Cloneable {
private static final Logger log = Log.get();
// --------------------------------------------------------------- Static method start
/**
* 创建认证器
*
* @return 认证器
*/
public static Auth build() {
return new Auth();
}
/**
* 创建认证器
*
* @param bucket Bucket
* @param key 文件key
* @param contentMd5 内容MD5
* @param date 日期
* @param config 配置文件
* @param request Http请求对象
*/
public static Auth build(
String bucket,
String key,
String contentMd5,
String date,
Config config,
HttpRequest request) {
return new Auth(bucket, key, contentMd5, date, config, request);
}
/**
* 用于签名的字符串
*
* @param bucket Bucket
* @param key 文件key
* @param contentMd5 内容的md5值
* @param date 日期
* @param request 请求对象
* @return 用于签名的字符串
*/
public static String strToSign(
String bucket, String key, String contentMd5, String date, HttpRequest request) {
String contentType = request.contentType();
if (StrUtil.isBlank(contentType)) {
contentType = "text/plain";
request.contentType(contentType);
log.warn("Content-Type header is empty, use default Content-Type: {}", contentType);
}
return StrUtil.builder()
.append(request.method())
.append("\n")
.append(StrUtil.nullToEmpty(contentMd5))
.append("\n")
.append(contentType)
.append("\n")
.append(StrUtil.nullToEmpty(date))
.append("\n")
.append(canonicalizedUcloudHeaders(request))
// canonicalizedUcloudHeaders尾部带一个换行符
.append(canonicalizedResource(bucket, key))
.toString();
}
/**
* 签名
*
* @param privateKey 私钥
* @param strToSign 被签名的字符串
* @return 签名
*/
public static String sign(String privateKey, String strToSign) {
return SignatureUtil.macSign(privateKey, strToSign);
}
/**
* 认证字符串
*
* @param publicKey 公钥
* @param signature 签名
* @return 认证字符串
*/
public static String authorization(String publicKey, String signature) {
return StrUtil.builder()
.append("UCloud ")
.append(publicKey)
.append(":")
.append(signature)
.toString();
}
/**
* 用于签名的标准Ucloud头信息字符串，尾部带换行符
*
* @param request Http请求
* @return 用于签名的Ucloud头信息字符串
*/
public static String canonicalizedUcloudHeaders(HttpRequest request) {
Param param = Param.create();
Map<String, String[]> headers = request.headers();
String[] value;
for (Entry<String, String[]> headerEntry : headers.entrySet()) {
String name = headerEntry.getKey().toLowerCase();
if (name.startsWith("x-ucloud-")) {
value = headerEntry.getValue();
if (value != null && value.length > 0) {
param.set(name, value[0]);
}
}
}
StringBuilder builder = StrUtil.builder();
for (Entry<String, Object> entry : param.entrySet()) {
builder.append(entry.getKey()).append(":").append(entry.getValue()).append("\n");
}
return builder.toString();
}
/**
* 用于签名的标准资源字符串
*
* @param bucket Bucket
* @param key 文件的key（在Ufile中的文件名）
* @return 标准资源字符串
*/
public static String canonicalizedResource(String bucket, String key) {
return StrUtil.builder().append("/").append(bucket).append("/").append(key).toString();
}
// --------------------------------------------------------------- Static method end
// --------------------------------------------------------------- Field start
/** Bucket */
private String bucket;
/** 文件在Bucket中的唯一名 */
private String key;
/** 文件的MD5 */
private String contentMd5 = StrUtil.EMPTY;
/** 日期 */
private String date = StrUtil.EMPTY;
/** 配置文件 */
private Config config;
/** Http请求对象 */
private HttpRequest request;
// --------------------------------------------------------------- Field end
/** 构造 */
public Auth() {}
/**
* 构造
*
* @param bucket Bucket
* @param key 文件key
* @param contentMd5 内容MD5
* @param date 日期
* @param config 配置文件
* @param request Http请求对象
*/
public Auth(
String bucket,
String key,
String contentMd5,
String date,
Config config,
HttpRequest request) {
super();
this.bucket = bucket;
this.key = key;
this.contentMd5 = contentMd5;
this.date = date;
this.config = config;
this.request = request;
}
// --------------------------------------------------------------- Getters and Setters start
/**
* 获得Bucket
*
* @return Bucket
*/
public String getBucket() {
return bucket;
}
/**
* 设置Bucket
*
* @param bucket Bucket
*/
public void setBucket(String bucket) {
this.bucket = bucket;
}
/** @return 文件key */
public String getKey() {
return key;
}
/**
* 设置文件key
*
* @param key 文件key
*/
public void setKey(String key) {
this.key = key;
}
/** @return 文件内容MD5 */
public String getContentMd5() {
return contentMd5;
}
/**
* 设置文件内容MD5
*
* @param contentMd5 文件内容MD5
*/
public void setContentMd5(String contentMd5) {
this.contentMd5 = contentMd5;
}
/** @return 日期 */
public String getDate() {
return date;
}
/**
* 设置日期
*
* @param date 日期
*/
public void setDate(String date) {
this.date = date;
}
/** @return 配置文件 */
public Config getConfig() {
return config;
}
/**
* 设置配置文件
*
* @param config 配置文件
*/
public void setConfig(Config config) {
this.config = config;
}
/** @return Http请求对象 */
public HttpRequest getRequest() {
return request;
}
/**
* 设置Http请求对象
*
* @param request Http请求对象
*/
public void setRequest(HttpRequest request) {
this.request = request;
}
// --------------------------------------------------------------- Getters and Setters end
/** 生成认证字符串 */
@Override
public String toString() {
final String strToSign = Auth.strToSign(bucket, key, contentMd5, date, request);
final String signature = Auth.sign(config.getPrivateKey(), strToSign);
final String authorization = Auth.authorization(config.getPublicKey(), signature);
return authorization;
}
/** 克隆对象 */
public Auth clone() {
try {
return (Auth) super.clone();
} catch (CloneNotSupportedException e) {
throw new RuntimeException(e.getMessage(), e);
}
}
}
