fsd-vod 0.11.1 → 0.13.0

package/index.d.ts

@@ -2,6 +2,14 @@ import { Adapter } from 'fsd';
 
 export interface VODAdapterOptions {
   urlPrefix?: string;
+  /**
+   * 是否公开读，默认为false
+   */
+  publicRead?: boolean;
+  /**
+   * 非公开读时，生成URL时的鉴权秘钥
+   */
+  privateKey?: string;
   accessKeyId: string;
   accessKeySecret: string;
   region?: string;
@@ -120,13 +128,47 @@ export interface UploadTokenWithAutoRefresh {
 }
 
 export default class VODAdpter extends Adapter<VODAdapterOptions> {
-  createUploadToken: (videoId: string, meta?: any) => Promise<UploadToken>;
+  /**
+   * 创建上传凭证
+   * @param {string} videoId 视频ID
+   * @param {any} [meta] 文件元信息
+   * @param {number} [durationSeconds] 上传凭证有效期，单位秒, 默认 3600
+   */
+  createUploadToken: (
+    videoId: string,
+    meta?: any,
+    durationSeconds?: number
+  ) => Promise<UploadToken>;
+
+  /**
+   * 创建带自动刷新的上传凭证
+   * @param {string} videoId 视频ID
+   * @param {any} [meta] 文件元信息
+   * @param {number} [durationSeconds] 上传凭证有效期，单位秒, 默认 3600
+   */
   createUploadTokenWithAutoRefresh: (
     videoId: string,
-    meta?: any
+    meta?: any,
+    durationSeconds?: number
   ) => Promise<UploadTokenWithAutoRefresh>;
 
+  /**
+   * 获取视频信息
+   * @param {string} videoId 视频ID
+   */
   getVideoInfo(videoId: string): Promise<null | VideoInfo>;
+
+  /**
+   * 获取视频播放信息
+   * @param {string} videoId 视频ID
+   * @param {any} [options] 参数选项
+   */
   getMezzanineInfo(videoId: string, options?: any): Promise<null | MezzanineInfo>;
+
+  /**
+   * 获取视频播放信息
+   * @param {string} videoId 视频ID
+   * @param {any} [options] 参数选项
+   */
   getPlayInfo(videoId: string, options?: any): Promise<null | PlayInfoResult>;
 }

package/lib/index.js

@@ -1,15 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-const LRUCache = require("lru-cache");
+const crypto = require("crypto");
+const stream_1 = require("stream");
+const lru_cache_1 = require("lru-cache");
 const Debugger = require("debug");
 const RPC = require("@alicloud/pop-core");
-const stream_1 = require("stream");
 const akita_1 = require("akita");
 const simple_oss_client_1 = require("fsd-oss/simple-oss-client");
 const debug = Debugger('fsd-vod');
 const client = akita_1.default.resolve('fsd-vod');
 const CALLBACK_BODY = 'bucket=${bucket}&path=${object}&etag=${etag}&size=${size}&mimeType=${mimeType}&height=${imageInfo.height}&width=${imageInfo.width}&format=${imageInfo.format}';
-function resultToCache(result) {
+function parseToken(result) {
     let UploadAddress = JSON.parse(Buffer.from(result.UploadAddress, 'base64').toString());
     let UploadAuth = JSON.parse(Buffer.from(result.UploadAuth, 'base64').toString());
     return {
@@ -24,6 +25,18 @@ function resultToCache(result) {
         expiration: UploadAuth.Expiration * 950
     };
 }
+function parseVideoId(id) {
+    if (id[0] === '/')
+        id = id.substring(1);
+    let path = '';
+    if (id.includes('#')) {
+        [id, path] = id.split('#');
+    }
+    return { id, path };
+}
+function md5(str) {
+    return crypto.createHash('md5').update(str).digest('hex');
+}
 class VODAdapter {
     constructor(options) {
         this.instanceOfFSDAdapter = true;
@@ -33,14 +46,16 @@ class VODAdapter {
             throw new Error('option accessKeyId is required for fsd-vod');
         if (!options.accessKeySecret)
             throw new Error('option accessKeySecret is required for fsd-vod');
+        if (!options.publicRead && !options.privateKey)
+            throw new Error('option privateKey is required when publicRead is false');
         this._options = options;
-        this._authCache = new LRUCache({
+        this._authCache = new lru_cache_1.LRUCache({
             max: 1000,
-            maxAge: 1800000
+            ttl: 1800000
         });
-        this._videoCache = new LRUCache({
+        this._videoCache = new lru_cache_1.LRUCache({
             max: 1000,
-            maxAge: 60000
+            ttl: 60000
         });
         this._rpc = new RPC({
             accessKeyId: options.accessKeyId,
@@ -73,24 +88,23 @@ class VODAdapter {
             let result = await this._rpc.request('CreateUploadVideo', params, { method: 'POST' });
             if (result.Message)
                 throw new Error(result.Message);
-            let token = resultToCache(result);
-            this._authCache.set(result.VideoId, token, token.expiration);
-            return result.VideoId;
+            let token = parseToken(result);
+            this._authCache.set(result.VideoId, token, { ttl: token.expiration });
+            return `/${result.VideoId}#${token.path}`;
         };
-        this.createUploadToken = async (videoId, meta) => {
-            if (videoId[0] === '/')
-                videoId = videoId.substring(1);
-            let token = this._authCache.get(videoId);
+        this.createUploadToken = async (videoId, meta, durationSeconds) => {
+            let vid = parseVideoId(videoId);
+            let token = this._authCache.get(vid.id);
             debug('getAuth', videoId, token);
             if (!token) {
                 let params = {
-                    VideoId: videoId
+                    VideoId: vid.id
                 };
                 let result = await this._rpc.request('RefreshUploadVideo', params, { method: 'POST' });
                 if (result.Message)
                     throw new Error(result.Message);
-                token = resultToCache(result);
-                this._authCache.set(videoId, token, token.expiration);
+                token = parseToken(result);
+                this._authCache.set(vid.id, token, { ttl: token.expiration });
             }
             if (options.callbackUrl && meta) {
                 token.callback = {
@@ -118,18 +132,17 @@ class VODAdapter {
         };
     }
     async getVideoInfo(videoId) {
-        if (videoId[0] === '/')
-            videoId = videoId.substring(1);
-        let cache = this._videoCache.get(videoId);
+        let vid = parseVideoId(videoId);
+        let cache = this._videoCache.get(vid.id);
         if (cache)
             return cache;
         let params = {
-            VideoId: videoId
+            VideoId: vid.id
         };
         try {
             let result = await this._rpc.request('GetVideoInfo', params, { method: 'POST' });
             if (result.Video) {
-                this._videoCache.set(videoId, result.Video);
+                this._videoCache.set(vid.id, result.Video);
                 return result.Video;
             }
         }
@@ -137,10 +150,9 @@ class VODAdapter {
         return null;
     }
     async getMezzanineInfo(videoId, options) {
-        if (videoId[0] === '/')
-            videoId = videoId.substring(1);
+        let vid = parseVideoId(videoId);
         let params = Object.assign({
-            VideoId: videoId,
+            VideoId: vid.id,
             OutputType: 'cdn'
         }, options || {});
         try {
@@ -153,10 +165,9 @@ class VODAdapter {
         return null;
     }
     async getPlayInfo(videoId, options) {
-        if (videoId[0] === '/')
-            videoId = videoId.substring(1);
+        let vid = parseVideoId(videoId);
         let params = Object.assign({
-            VideoId: videoId
+            VideoId: vid.id
         }, options || {});
         return await this._rpc.request('GetPlayInfo', params, { method: 'POST' });
     }
@@ -172,6 +183,7 @@ class VODAdapter {
     async createReadStream(videoId, options) {
         debug('createReadStream %s options: %o', videoId, options);
         let url = await this.createUrl(videoId);
+        console.log('url', url);
         let headers = {};
         if (options) {
             let start = options.start || 0;
@@ -239,6 +251,26 @@ class VODAdapter {
     }
     async createUrl(videoId, options) {
         debug('createUrl %s', videoId);
+        options = options || {};
+        let vid = parseVideoId(videoId);
+        let path = options.path || vid.path;
+        if (path && this._options.publicRead) {
+            if (/^https?\:\/\//.test(path))
+                return path;
+            return `${this._options.urlPrefix || ''}${path}`;
+        }
+        if (path) {
+            let urlPrefix = this._options.urlPrefix || '';
+            if (/^https?\:\/\//.test(path)) {
+                let url = new URL(path);
+                path = url.pathname;
+                urlPrefix = url.origin;
+            }
+            let timestamp = parseInt((Date.now() / 1000));
+            let string = `${path}-${timestamp}-0-0-${this._options.privateKey}`;
+            let hash = md5(string);
+            return `${urlPrefix}${path}?auth_key=${timestamp}-0-0-${hash}`;
+        }
         let info = await this.getMezzanineInfo(videoId, options);
         if (info)
             return info.FileURL;
@@ -246,14 +278,15 @@ class VODAdapter {
     }
     async unlink(videoId) {
         debug('unlink %s', videoId);
-        if (videoId[0] === '/')
-            videoId = videoId.substring(1);
+        let vid = parseVideoId(videoId);
         let params = {
-            VideoIds: videoId
+            VideoIds: vid.id
         };
         let result = await this._rpc.request('DeleteVideo', params, { method: 'POST' });
         if (result.Message)
             throw new Error(result.Message);
+        this._videoCache.delete(vid.id);
+        this._authCache.delete(vid.id);
     }
     async exists(videoId) {
         return !!(await this.getVideoInfo(videoId));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fsd-vod",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "description": "Aliyun OSS adapter for fsd",
   "main": "lib/index.js",
   "types": "index.d.ts",
@@ -12,11 +12,11 @@
   "author": "Liang <liang@miaomo.cc> (https://github.com/liangxingchen)",
   "license": "MIT",
   "dependencies": {
-    "@alicloud/pop-core": "^1.7.12",
+    "@alicloud/pop-core": "^1.7.13",
     "akita": "^1.0.4",
     "debug": "^4.3.4",
-    "fsd-oss": "^0.11.1",
-    "lru-cache": "^6.0.0"
+    "fsd-oss": "^0.13.0",
+    "lru-cache": "^9.1.1"
   },
-  "gitHead": "5f39a56e4f5ae28e6f15c7888413561a924b54de"
+  "gitHead": "1548128573c0fd22977706a6704029ec3ca3bab6"
 }