Implemented 'stream.Readable' and 'stream.Writable' for the 'write' a…

…nd 'read' methods of resources instead of using a 'Int8Array'
OpenMarshal · May 30, 2017 · b88370a · b88370a
1 parent 9f1f60c
commit b88370a
Show file tree

Hide file tree

Showing 31 changed files with 270 additions and 330 deletions.
diff --git a/lib/resource/IResource.d.ts b/lib/resource/IResource.d.ts
@@ -1,5 +1,5 @@
 /// <reference types="node" />
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { FSManager } from '../manager/FSManager';
 import { XMLElement } from '../helper/XML';
 import { LockKind } from './lock/LockKind';
@@ -29,9 +29,8 @@ export interface IResource {
     rename(newName: string, callback: Return2Callback<string, string>): any;
     isSame(resource: IResource, callback: ReturnCallback<boolean>): any;
     isOnTheSameFSWith(resource: IResource, callback: ReturnCallback<boolean>): any;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): any;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): any;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): any;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): any;
     size(targetSource: boolean, callback: ReturnCallback<number>): any;
     getLocks(callback: ReturnCallback<Lock[]>): any;

diff --git a/lib/resource/physical/PhysicalFile.d.ts b/lib/resource/physical/PhysicalFile.d.ts
@@ -1,16 +1,15 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { PhysicalResource } from './PhysicalResource';
 import { FSManager } from '../../manager/FSManager';
 export declare class PhysicalFile extends PhysicalResource {
     constructor(realPath: string, parent?: IResource, fsManager?: FSManager);
     type(callback: ReturnCallback<ResourceType>): void;
     create(callback: SimpleCallback): void;
     delete(callback: SimpleCallback): void;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): void;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): void;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): void;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): void;
     size(targetSource: boolean, callback: ReturnCallback<number>): void;
     addChild(resource: IResource, callback: SimpleCallback): void;

diff --git a/lib/resource/physical/PhysicalFile.js b/lib/resource/physical/PhysicalFile.js
@@ -47,31 +47,28 @@ var PhysicalFile = (function (_super) {
                 _this.removeFromParent(callback);
         });
     };
-    PhysicalFile.prototype.append = function (data, targetSource, callback) {
+    PhysicalFile.prototype.write = function (targetSource, callback) {
         var _this = this;
-        fs.appendFile(this.realPath, data, function (e) {
-            if (e)
-                callback(e);
-            else {
-                _this.updateLastModified();
-                callback(null);
+        fs.open(this.realPath, 'w', function (e, fd) {
+            if (e) {
+                callback(e, null);
+                return;
             }
+            callback(null, fs.createWriteStream(null, { fd: fd }));
+            _this.updateLastModified();
         });
     };
-    PhysicalFile.prototype.write = function (data, targetSource, callback) {
+    PhysicalFile.prototype.read = function (targetSource, callback) {
         var _this = this;
-        fs.writeFile(this.realPath, data, function (e) {
-            if (e)
-                callback(e);
-            else {
-                _this.updateLastModified();
-                callback(null);
+        fs.open(this.realPath, 'r', function (e, fd) {
+            if (e) {
+                callback(e, null);
+                return;
             }
+            callback(null, fs.createReadStream(null, { fd: fd }));
+            _this.updateLastModified();
         });
     };
-    PhysicalFile.prototype.read = function (targetSource, callback) {
-        fs.readFile(this.realPath, callback);
-    };
     PhysicalFile.prototype.mimeType = function (targetSource, callback) {
         var mt = mimeTypes.lookup(this.realPath);
         callback(null, mt ? mt : 'application/octet-stream');

diff --git a/lib/resource/physical/PhysicalFolder.d.ts b/lib/resource/physical/PhysicalFolder.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { ResourceChildren } from '../std/ResourceChildren';
 import { PhysicalResource } from './PhysicalResource';
 import { FSManager } from '../../manager/FSManager';
@@ -10,9 +10,8 @@ export declare class PhysicalFolder extends PhysicalResource {
     type(callback: ReturnCallback<ResourceType>): void;
     create(callback: SimpleCallback): void;
     delete(callback: SimpleCallback): void;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): void;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): void;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): void;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): void;
     size(targetSource: boolean, callback: ReturnCallback<number>): void;
     addChild(resource: IResource, callback: SimpleCallback): void;

diff --git a/lib/resource/physical/PhysicalFolder.js b/lib/resource/physical/PhysicalFolder.js
@@ -69,11 +69,8 @@ var PhysicalFolder = (function (_super) {
             });
         });
     };
-    PhysicalFolder.prototype.append = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
-    };
-    PhysicalFolder.prototype.write = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
+    PhysicalFolder.prototype.write = function (targetSource, callback) {
+        callback(Errors_1.Errors.InvalidOperation, null);
     };
     PhysicalFolder.prototype.read = function (targetSource, callback) {
         callback(Errors_1.Errors.InvalidOperation, null);
@@ -93,7 +90,11 @@ var PhysicalFolder = (function (_super) {
         });
     };
     PhysicalFolder.prototype.removeChild = function (resource, callback) {
-        this.children.remove(resource, callback);
+        this.children.remove(resource, function (e) {
+            if (!e)
+                resource.parent = null;
+            callback(e);
+        });
     };
     PhysicalFolder.prototype.getChildren = function (callback) {
         callback(null, this.children.children);

diff --git a/lib/resource/physical/PhysicalResource.d.ts b/lib/resource/physical/PhysicalResource.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, Return2Callback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { StandardResource } from '../std/StandardResource';
 import { FSManager } from '../../manager/FSManager';
 export declare abstract class PhysicalResource extends StandardResource {
@@ -13,9 +13,8 @@ export declare abstract class PhysicalResource extends StandardResource {
     rename(newName: string, callback: Return2Callback<string, string>): void;
     webName(callback: ReturnCallback<string>): void;
     abstract type(callback: ReturnCallback<ResourceType>): any;
-    abstract append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): any;
+    abstract write(targetSource: boolean, callback: ReturnCallback<Writable>): any;
+    abstract read(targetSource: boolean, callback: ReturnCallback<Readable>): any;
     abstract mimeType(targetSource: boolean, callback: ReturnCallback<string>): any;
     abstract size(targetSource: boolean, callback: ReturnCallback<number>): any;
     abstract addChild(resource: IResource, callback: SimpleCallback): any;

diff --git a/lib/resource/std/RootResource.d.ts b/lib/resource/std/RootResource.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, Return2Callback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { StandardResource } from './StandardResource';
 import { ResourceChildren } from './ResourceChildren';
 export declare class RootResource extends StandardResource {
@@ -12,9 +12,8 @@ export declare class RootResource extends StandardResource {
     rename(newName: string, callback: Return2Callback<string, string>): void;
     webName(callback: ReturnCallback<string>): void;
     type(callback: ReturnCallback<ResourceType>): void;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): void;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): void;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): void;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): void;
     size(targetSource: boolean, callback: ReturnCallback<number>): void;
     addChild(resource: IResource, callback: SimpleCallback): void;

diff --git a/lib/resource/std/RootResource.js b/lib/resource/std/RootResource.js
@@ -40,11 +40,8 @@ var RootResource = (function (_super) {
     RootResource.prototype.type = function (callback) {
         callback(null, IResource_1.ResourceType.Directory);
     };
-    RootResource.prototype.append = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
-    };
-    RootResource.prototype.write = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
+    RootResource.prototype.write = function (targetSource, callback) {
+        callback(Errors_1.Errors.InvalidOperation, null);
     };
     RootResource.prototype.read = function (targetSource, callback) {
         callback(Errors_1.Errors.InvalidOperation, null);

diff --git a/lib/resource/std/StandardResource.d.ts b/lib/resource/std/StandardResource.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IResource, ReturnCallback, SimpleCallback, Return2Callback, ResourceType, ResourcePropertyValue } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { FSManager } from '../../manager/FSManager';
 import { LockKind } from '../lock/LockKind';
 import { LockBag } from '../lock/LockBag';
@@ -31,9 +31,8 @@ export declare abstract class StandardResource implements IResource {
     abstract delete(callback: SimpleCallback): any;
     abstract moveTo(parent: IResource, newName: string, overwrite: boolean, callback: SimpleCallback): any;
     abstract rename(newName: string, callback: Return2Callback<string, string>): any;
-    abstract append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): any;
+    abstract write(targetSource: boolean, callback: ReturnCallback<Writable>): any;
+    abstract read(targetSource: boolean, callback: ReturnCallback<Readable>): any;
     abstract mimeType(targetSource: boolean, callback: ReturnCallback<string>): any;
     abstract size(targetSource: boolean, callback: ReturnCallback<number>): any;
     creationDate(callback: ReturnCallback<number>): void;

diff --git a/lib/resource/virtual/VirtualFile.d.ts b/lib/resource/virtual/VirtualFile.d.ts
@@ -1,22 +1,26 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, ResourceType } from '../IResource';
-import { Readable, ReadableOptions } from 'stream';
+import { Readable, Writable } from 'stream';
 import { VirtualResource } from './VirtualResource';
 import { FSManager } from '../../manager/FSManager';
 export declare class VirtualFileReadable extends Readable {
     contents: Int8Array[];
     blockIndex: number;
-    constructor(contents: Int8Array[], options?: ReadableOptions);
+    constructor(contents: Int8Array[]);
     _read(size: number): void;
 }
+export declare class VirtualFileWritable extends Writable {
+    contents: Int8Array[];
+    constructor(contents: Int8Array[]);
+    _write(chunk: Buffer | string | any, encoding: string, callback: (error: Error) => void): void;
+}
 export declare class VirtualFile extends VirtualResource {
     content: Int8Array[];
     len: number;
     constructor(name: string, parent?: IResource, fsManager?: FSManager);
     type(callback: ReturnCallback<ResourceType>): void;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): void;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): void;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): void;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): void;
     size(targetSource: boolean, callback: ReturnCallback<number>): void;
     addChild(resource: IResource, callback: SimpleCallback): void;

diff --git a/lib/resource/virtual/VirtualFile.js b/lib/resource/virtual/VirtualFile.js
@@ -17,8 +17,8 @@ var Errors_1 = require("../../Errors");
 var mimeTypes = require("mime-types");
 var VirtualFileReadable = (function (_super) {
     __extends(VirtualFileReadable, _super);
-    function VirtualFileReadable(contents, options) {
-        var _this = _super.call(this, options) || this;
+    function VirtualFileReadable(contents) {
+        var _this = _super.call(this) || this;
         _this.contents = contents;
         _this.blockIndex = -1;
         return _this;
@@ -37,6 +37,20 @@ var VirtualFileReadable = (function (_super) {
     return VirtualFileReadable;
 }(stream_1.Readable));
 exports.VirtualFileReadable = VirtualFileReadable;
+var VirtualFileWritable = (function (_super) {
+    __extends(VirtualFileWritable, _super);
+    function VirtualFileWritable(contents) {
+        var _this = _super.call(this, null) || this;
+        _this.contents = contents;
+        return _this;
+    }
+    VirtualFileWritable.prototype._write = function (chunk, encoding, callback) {
+        this.contents.push(chunk);
+        callback(null);
+    };
+    return VirtualFileWritable;
+}(stream_1.Writable));
+exports.VirtualFileWritable = VirtualFileWritable;
 var VirtualFile = (function (_super) {
     __extends(VirtualFile, _super);
     function VirtualFile(name, parent, fsManager) {
@@ -48,17 +62,16 @@ var VirtualFile = (function (_super) {
     VirtualFile.prototype.type = function (callback) {
         callback(null, IResource_1.ResourceType.File);
     };
-    VirtualFile.prototype.append = function (data, targetSource, callback) {
-        this.content.push(data);
-        this.len += data.length;
-        this.updateLastModified();
-        callback(null);
-    };
-    VirtualFile.prototype.write = function (data, targetSource, callback) {
-        this.content = [data];
-        this.len = data.length;
-        this.updateLastModified();
-        callback(null);
+    VirtualFile.prototype.write = function (targetSource, callback) {
+        var _this = this;
+        var content = [];
+        var stream = new VirtualFileWritable(content);
+        stream.on('finish', function () {
+            _this.content = content;
+            _this.len = content.map(function (c) { return c.length; }).reduce(function (s, n) { return s + n; }, 0);
+            _this.updateLastModified();
+        });
+        callback(null, stream);
     };
     VirtualFile.prototype.read = function (targetSource, callback) {
         callback(null, new VirtualFileReadable(this.content));

diff --git a/lib/resource/virtual/VirtualFolder.d.ts b/lib/resource/virtual/VirtualFolder.d.ts
@@ -1,16 +1,15 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { ResourceChildren } from '../std/ResourceChildren';
 import { VirtualResource } from './VirtualResource';
 import { FSManager } from '../../manager/FSManager';
 export declare class VirtualFolder extends VirtualResource {
     children: ResourceChildren;
     constructor(name: string, parent?: IResource, fsManager?: FSManager);
     type(callback: ReturnCallback<ResourceType>): void;
-    append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): void;
-    read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): void;
+    write(targetSource: boolean, callback: ReturnCallback<Writable>): void;
+    read(targetSource: boolean, callback: ReturnCallback<Readable>): void;
     mimeType(targetSource: boolean, callback: ReturnCallback<string>): void;
     size(targetSource: boolean, callback: ReturnCallback<number>): void;
     addChild(resource: IResource, callback: SimpleCallback): void;

diff --git a/lib/resource/virtual/VirtualFolder.js b/lib/resource/virtual/VirtualFolder.js
@@ -25,11 +25,8 @@ var VirtualFolder = (function (_super) {
     VirtualFolder.prototype.type = function (callback) {
         callback(null, IResource_1.ResourceType.Directory);
     };
-    VirtualFolder.prototype.append = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
-    };
-    VirtualFolder.prototype.write = function (data, targetSource, callback) {
-        callback(Errors_1.Errors.InvalidOperation);
+    VirtualFolder.prototype.write = function (targetSource, callback) {
+        callback(Errors_1.Errors.InvalidOperation, null);
     };
     VirtualFolder.prototype.read = function (targetSource, callback) {
         callback(Errors_1.Errors.InvalidOperation, null);
@@ -49,7 +46,11 @@ var VirtualFolder = (function (_super) {
         });
     };
     VirtualFolder.prototype.removeChild = function (resource, callback) {
-        this.children.remove(resource, callback);
+        this.children.remove(resource, function (e) {
+            if (!e)
+                resource.parent = null;
+            callback(e);
+        });
     };
     VirtualFolder.prototype.getChildren = function (callback) {
         callback(null, this.children.children);

diff --git a/lib/resource/virtual/VirtualResource.d.ts b/lib/resource/virtual/VirtualResource.d.ts
@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IResource, SimpleCallback, ReturnCallback, Return2Callback, ResourceType } from '../IResource';
-import { Readable } from 'stream';
+import { Readable, Writable } from 'stream';
 import { FSManager } from '../../manager/FSManager';
 import { StandardResource } from '../std/StandardResource';
 export declare abstract class VirtualResource extends StandardResource {
@@ -12,9 +12,8 @@ export declare abstract class VirtualResource extends StandardResource {
     rename(newName: string, callback: Return2Callback<string, string>): void;
     webName(callback: ReturnCallback<string>): void;
     abstract type(callback: ReturnCallback<ResourceType>): any;
-    abstract append(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract write(data: Int8Array, targetSource: boolean, callback: SimpleCallback): any;
-    abstract read(targetSource: boolean, callback: ReturnCallback<Int8Array | Readable>): any;
+    abstract write(targetSource: boolean, callback: ReturnCallback<Writable>): any;
+    abstract read(targetSource: boolean, callback: ReturnCallback<Readable>): any;
     abstract mimeType(targetSource: boolean, callback: ReturnCallback<string>): any;
     abstract size(targetSource: boolean, callback: ReturnCallback<number>): any;
     abstract addChild(resource: IResource, callback: SimpleCallback): any;