118 lines
3.3 KiB
TypeScript
118 lines
3.3 KiB
TypeScript
import * as plugins from './smartbucket.plugins';
|
|
import { SmartBucket } from './smartbucket.classes.smartbucket';
|
|
import { Directory } from './smartbucket.classes.directory';
|
|
import { Observable } from 'rxjs';
|
|
|
|
export class Bucket {
|
|
public static async getBucketByName(smartbucketRef: SmartBucket, bucketNameArg: string) {
|
|
const buckets = await smartbucketRef.minioClient.listBuckets();
|
|
const foundBucket = buckets.find(bucket => {
|
|
return bucket.name === bucketNameArg;
|
|
});
|
|
|
|
if (foundBucket) {
|
|
console.log(`bucket with name ${bucketNameArg} exists.`);
|
|
console.log(`Taking this as base for new Bucket instance`);
|
|
return new this(smartbucketRef, bucketNameArg);
|
|
} else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static async createBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
|
|
await smartbucketRef.minioClient.makeBucket(bucketName, 'ams3').catch(e => console.log(e));
|
|
return new Bucket(smartbucketRef, bucketName);
|
|
}
|
|
|
|
public static async removeBucketByName(smartbucketRef: SmartBucket, bucketName: string) {
|
|
await smartbucketRef.minioClient.removeBucket(bucketName).catch(e => console.log(e));
|
|
}
|
|
|
|
public smartbucketRef: SmartBucket;
|
|
public name: string;
|
|
|
|
constructor(smartbucketRef: SmartBucket, bucketName: string) {
|
|
this.smartbucketRef = smartbucketRef;
|
|
this.name = bucketName;
|
|
}
|
|
|
|
/**
|
|
* gets the base directory of the bucket
|
|
*/
|
|
public async getBaseDirectory() {
|
|
return new Directory(this, null, '');
|
|
}
|
|
|
|
// ===============
|
|
// Fast Operations
|
|
// ===============
|
|
|
|
/**
|
|
* store file
|
|
*/
|
|
public async fastStore(pathArg: string, fileContent: string) {
|
|
const streamIntake = new plugins.streamfunction.Intake();
|
|
const putPromise = this.smartbucketRef.minioClient
|
|
.putObject(this.name, pathArg, streamIntake.getReadable())
|
|
.catch(e => console.log(e));
|
|
streamIntake.pushData(fileContent);
|
|
streamIntake.signalEnd();
|
|
await putPromise;
|
|
}
|
|
|
|
/**
|
|
* get file
|
|
*/
|
|
public async fastGet(pathArg: string) {
|
|
const done = plugins.smartpromise.defer();
|
|
let completeFile: string = '';
|
|
const replaySubject = await this.fastGetStream(pathArg);
|
|
replaySubject.subscribe(
|
|
chunkString => {
|
|
completeFile += chunkString;
|
|
},
|
|
err => {
|
|
console.log(err);
|
|
},
|
|
() => {
|
|
done.resolve();
|
|
}
|
|
);
|
|
await done.promise;
|
|
return completeFile;
|
|
}
|
|
|
|
public async fastGetStream(pathArg: string): Promise<plugins.smartrx.rxjs.ReplaySubject<string>> {
|
|
const fileStream = await this.smartbucketRef.minioClient
|
|
.getObject(this.name, pathArg)
|
|
.catch(e => console.log(e));
|
|
const replaySubject = new plugins.smartrx.rxjs.ReplaySubject<string>();
|
|
const duplexStream = plugins.streamfunction.createDuplexStream<Buffer, Buffer>(
|
|
async chunk => {
|
|
const chunkString = chunk.toString();
|
|
replaySubject.next(chunkString);
|
|
return chunk;
|
|
},
|
|
async cb => {
|
|
console.log('stream ended');
|
|
replaySubject.complete();
|
|
return Buffer.from('');
|
|
}
|
|
);
|
|
|
|
if (!fileStream) {
|
|
return null;
|
|
}
|
|
|
|
fileStream.pipe(duplexStream);
|
|
return replaySubject;
|
|
}
|
|
|
|
/**
|
|
* removeObject
|
|
*/
|
|
public async fastRemove(pathArg: string) {
|
|
await this.smartbucketRef.minioClient.removeObject(this.name, pathArg);
|
|
}
|
|
}
|