node scalable blob store
Last release prior to upgrading to async
Un magasin BLOB du système de fichiers conçu pour empêcher les conflits lorsqu'il est utilisé avec un système de fichiers distribué ou un réseau de zone de stockage.
Veuillez jouer sur GitHub / NPM et surveiller les mises à jour.
Remarque: nécessite Node.js v12 ou version ultérieure.
npm install scalable-blob-store --save
const os = require ( 'os' ) ;
const ulid = require ( 'ulid' ) . ulid ; // You need a unique ID generator function
const BlobStore = require ( 'scalable-blob-store' ) ;
const options = {
blobStoreRoot : os . tmpdir ( ) + '/blobs' , // Change this!
idFunction : ulid ,
dirDepth : 4 ,
dirWidth : 1000 ,
} ;
// Creating the blobStore Object
const blobStore = new BlobStore ( options ) ;
const result = await blobStore . createWriteStream ( ) ;
console . dir ( result ) ;
// Logs the result object which contains the blobPath and writeStream.
// Use the writeStream to save your blob.
// Store the blobPath in your database.
//
// result object will be similar to this:
// {
// blobPath: "/01CTZRTWMAD153V20K26S4Y0BW/01CTZRTWMBZW4SPR4E5QGGJYSH/01CTZRTWMB3QXZK04SYFY8ZJVR/01CTZS3KJYFPRQ34S3T15Y798S",
// writeStream: [WriteStream]
// }
//
// In this example the full file path for the blob would be something like this:
// /tmp/blobs/01CTZRTWMAD153V20K26S4Y0BW/01CTZRTWMBZW4SPR4E5QGGJYSH/01CTZRTWMB3QXZK04SYFY8ZJVR/01CTZS3KJYFPRQ34S3T15Y798S
//
// This is based on the blobStoreRoot + blobPath.Voir l'exemple de démarrage rapide pour plus de détails:
Après les recherches sur le stockage de fichiers utilisateur, ou le stockage blob, pour une application Web sur laquelle je travaillais, j'ai découvert que la solution la plus courante utilisée par les développeurs Web est de stocker des fichiers à l'aide d'un fournisseur de services cloud. Après avoir créé un compte avec des fournisseurs tels que Amazon S3, Google Cloud Storage ou Azure Storage, ils cachent simplement tous leurs fichiers d'application et bloquent.
J'ai fait des recherches sur le prix du stockage cloud et j'ai décidé que je voulais une version locale gratuite qui s'adapterait si nécessaire.
J'ai examiné un certain nombre de solutions existantes telles que FileStorage, mais je n'étais pas satisfaite de l'évolutivité de ces solutions. La plupart sont conçus uniquement pour un seul serveur et provoqueraient des conflits d'écriture si un système de fichiers distribué, un système de fichiers de cluster comme GlusterFS ou un réseau de zone de stockage était utilisé comme système de fichiers backend.
Lors d'un long voyage en voiture, je pensais à une solution pour mon stockage blob et j'ai trouvé scalable-blob-store .
Pour atteindre l'évolutivité sur un système de fichiers distribué ou reproduit, scalable-blob-store n'utilise pas de fichiers index ou d'autres bases de données pour gérer les fichiers du disque ou du système de stockage. Au lieu de cela, le système de fichiers lui-même est utilisé pour trouver le dernier chemin de stockage en fonction de l'attribut birthtime des systèmes de fichiers (la date de création du répertoire).
Une fois le dernier chemin déterminé, le nombre de fichiers dans le répertoire est compté pour s'assurer qu'il reste sous la valeur configurée. Il s'agit d'éviter les problèmes de performances du disque lorsque un très grand nombre de fichiers sont stockés dans un seul répertoire. Si le nombre d'articles dans un répertoire devient trop grand, un nouveau chemin de stockage est déterminé.
Étant donné qu'il n'y a pas de bases de données utilisées pour gérer les fichiers du chemin racine, c'est à vous de maintenir la valeur blobPath renvoyée et les métadonnées sur les fichiers stockés dans votre propre base de données.
La raison pour laquelle scalable-blob-store est évolutif est due à la dénomination des répertoires et des fichiers dans votre système de fichiers. Chaque répertoire et fichier enregistré sur le disque est nommé par un ID unique généré basé sur un funciton défini par l'utilisateur. Vous pouvez utiliser n'importe quel générateur d'ID unique tel que ULID, CUID, UUID V4 ou MongoDBS Objectid pour n'en nommer que quelques-uns. Découvrez mon impressionnant référentiel d'identification unique pour plus d'exemples. La fusion des répertoires entre serveurs ou disques ne devrait jamais provoquer des collisions de noms de fichier.
Si un système de fichiers reproduit ou de cluster est utilisé, le seul conflit qui peut se produire est lorsqu'un serveur lit un fichier tandis qu'un autre supprime le même fichier. scalable-blob-store n'essaie pas de gérer ce conflit, mais il augmentera l'exception.
Vous trouverez ci-dessous des exemples de la structure du répertoire créé par scalable-blob-store .
Exemple avec le répertoire CUID et les noms de fichiers:
b lobs c ij50xia200pzzph3we9r62bi // ← Directory File ↓
b lobs c ij50xia300q1zph3m4df4ypz . . c ij50xiae00qgzph3i0ms0l2wExemple avec le répertoire UUID et les noms de fichiers:
b lobs 8 46a291f-9864-40bb-aefe-f29bdc73a761 // ← Directory File ↓
b lobs 8 46a291f-9864-40bb-aefe-f29bdc73a761 . . 8 b86b6fe-6166-424c-aed9-8faf1e62689e scalable-blob-store prend en charge les options de configuration pour vous donner le contrôle sur le répertoire et les ID de fichier utilisé, la profondeur de la structure du répertoire et la largeur des répertoires. Les options par défaut donnent 3 répertoires en profondeur contenant 1000 éléments donnant un stockage total d'un milliard de fichiers dans la structure du répertoire.
Autres points d'intérêt opérationnels:
dirWidth , le prochain répertoire est créé.dirWidth , le prochain répertoire parent est créé.dirWidth , la valeur dirWidth est ignorée. Écrire
Sur mon ordinateur portable avec un disque SSD M.2, l'exécution du script Test-Fs.js produit les résultats suivants:
====================================================================================================
Testing scalable-blob-store with the following options:
blobStoreRoot: /tmp/blobs/test-fs
idFunction: ulid
dirDepth: 3
dirWidth: 1000
repeat: 10000
Beginning test...
====================================================================================================
Test complete.
====================================================================================================
{
blobStoreRoot: '/tmp/blobs/test-fs',
dirDepth: 3,
dirWidth: 1000,
runTimeMilliseconds: 83730,
totalDirectories: 12,
totalFiles: 10000,
totalBytes: 430000,
lastBlobPath: '/ckxwcwgwz0001lk9hgq8t9iup/ckxwcwgx00002lk9h6tbpdmq1/ckxwcy36m06yclk9hb0g92dwg/ckxwcy9ip07q4lk9h5uyl10k6'
}
====================================================================================================
Please remove /tmp/blobs/test-fs manually.
====================================================================================================
Lire
Les performances de lecture seront proches, sinon la même, que la vitesse du disque.
Toutes les méthodes Blobstore dans scalable-blob-store renvoient une promesse. Ceci est parfait pour l'utilisation avec les fonctionnalités linguistiques asynchrones / attend.
| API | Taper | Rendements |
|---|---|---|
| Nouveau Blobstore (Options) | Constructeur | instance Blobstore |
| blobstore.blobstoreroot | Lire uniquement la propriété | String |
| blobstore.idfunction | Lire uniquement la propriété | Function |
| Blobstore.DirdEpth | Lire uniquement la propriété | Number |
| Blobstore.dirwidth | Lire uniquement la propriété | Number |
| blobstore.getCurrentBlobdir () | Méthode | Promise<String> |
| Blobstore.setCurrentBlobdir (Blobdir) | Méthode | Promise<undefined> |
| Blobstore.CreateWRiteStream () | Méthode | Promise<Object> |
| Blobstore.Write (données, WriteOptions) | Méthode | Promise<String> |
| BLOBSTORE.APPEND (BLOBPATH, DONNÉES, APPENDOPTIONS) | Méthode | Promise<undefined> |
| Blobstore.copy (Blobpath, Flags) | Méthode | Promise<String> |
| BLOBSTORE.CREAREADSTREAM (BLOBPATH) | Méthode | Promise<ReadStream> |
| Blobstore.read (Blobpath, ReadOptions) | Méthode | Promise<data> |
| Blobstore.Open (Blobpath, Flags, Mode) | Méthode | Promise<FileHandle> |
| Blobstore.realpath (Blobpath, realPathoptions) | Méthode | Promise<String> |
| Blobstore.stat (Blobpath) | Méthode | Promise<Stats> |
| Blobstore.exists (Blobpath) | Méthode | Promise<Boolean> |
| BLOBSTORE.REMOVE (BLOBPATH) | Méthode | Promise<undefined> |
new BlobStore(options)Type: fonction du constructeur.
Paramètre: options en tant Object .
Renvoie : un nouvel objet BlobStore à utiliser pour stocker des données.
Description:
Vous pouvez appeler new BlobStore(options) plusieurs fois pour créer plus d'un magasin Blob.
Les options sont transmises à la fonction constructeur comme un object JavaScript.
| Clé | Description | Par défaut |
|---|---|---|
blobStoreRoot | Répertoire racine pour stocker des taches | Requis |
idFunction | Toute fonction d'ID qui renvoie une chaîne d'ID unique | Requis |
dirDepth | À quelle profondeur voulez-vous les répertoires sous la racine | 3 |
dirWidth | Le nombre maximum de fichiers ou de répertoires dans un répertoire | 1000 |
Exemple:
// Start by requiring the `scalable-blob-store` constructor function:
const BlobStore = require ( 'scalable-blob-store' ) ;
// You will need a unique ID function
const uuid = require ( 'uuid' ) ;
// Create the options object
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
// Create a blob store using the options `object`:
const blobStore = new BlobStore ( options ) ;Création de plusieurs magasins Blob:
const userOptions = {
blobStoreRoot : '/app/blobs/user' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
const pdfOptions = {
blobStoreRoot : '/app/blobs/pdf' ,
idFunction : uuid . v4 ,
dirDepth : 2 ,
dirWidth : 300 ,
} ;
const userFileStore = new BlobStore ( userOptions ) ;
const pdfDocumentStore = new BlobStore ( pdfOptions ) ;blobStoreRootType: Lire uniquement la propriété.
Renvoie: une String qui correspond à vos options.blobStoreRoot Value.
Description:
Il s'agit d'une propriété de commodité pour vous permettre de passer l'objet Blobstore à un sous-module et d'avoir toujours accès aux propriétés configurées.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
console . log ( blobStore . blobStoreRoot ) ;
// Outputs '/app/blobs' which you configured in the optionsidFunctionType: Lire uniquement la propriété.
Renvoie: la fonction ID unique que vous avez configurée dans la valeur options.idFunction .
Description:
Il s'agit d'une propriété de commodité pour vous permettre de passer l'objet Blobstore à un sous-module et d'avoir toujours accès aux propriétés configurées.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
console . log ( blobStore . idFunction ( ) ) ;
// Outputs 'bac00ab2-5e6d-4b77-bfa4-e9befc3e4279' which is a generated UUID from the idFunction.dirDepthType: Lire uniquement la propriété.
Renvoie: un Number qui correspond à vos options.dirDepth .
Description:
Il s'agit d'une propriété de commodité pour vous permettre de passer l'objet Blobstore à un sous-module et d'avoir toujours accès aux propriétés configurées.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
console . log ( blobStore . dirDepth ) ;
// Outputs '4' which you configured in the optionsdirWidthType: Lire uniquement la propriété.
Renvoie: un Number qui correspond à vos options.dirWidth .
Description:
Il s'agit d'une propriété de commodité pour vous permettre de passer l'objet Blobstore à un sous-module et d'avoir toujours accès aux propriétés configurées.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 4 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
console . log ( blobStore . dirWidth ) ;
// Outputs '2000' which you configured in the optionsgetCurrentBlobDir()Type: méthode.
Renvoie: une Promise qui se résout en une String qui est le répertoire de création BLOB actif actuel.
Description:
Cette fonction est utilisée en interne par le BlobStore pour déterminer le répertoire où le prochain fichier blob sera enregistré sur le disque.
Si vous avez besoin de stocker un fichier blob en dehors du BlobStore , vous pouvez utiliser cette méthode pour localiser le bon endroit pour mettre votre fichier.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
console . log ( await blobStore . getCurrentBlobDir ( ) ) ;
// The 'dirDepth' option above is set to 3 so the output will be similar to the following:
// '/e44d3b0d-b552-4257-8b64-a53331184c38/443061b9-bfa7-40fc-a5a9-d848bc52155e/4d818f4c-88b3-45fd-a104-a2fc3700e9de'
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;setCurrentBlobDir(blobDir)Type: méthode.
Paramètres: blobDir en tant que String .
blobStoreRoot . Renvoie: une Promise qui se résout à undefined .
Description:
Cette fonction peut être utilisée pour guider le BlobStore pour enregistrer de nouveaux fichiers Blob dans un blobPath souhaité.
Un problème avec scalable-blob-store est que si vous supprimez de nombreux fichiers blob, les répertoires dans lesquels se trouvaient ne seront pas supprimés. Vous pouvez soit supprimer les répertoires vous-même, soit les repeupler avec de nouveaux fichiers blob en définissant le répertoire BLOB actif actuel.
Cette fonction a été ajoutée pour permettre aux consommateurs de ce module de contourner les répertoires BLOB vides.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
console . log ( await blobStore . getCurrentBlobDir ( ) ) ;
// The 'dirDepth' option above is set to 3 so the output will be similar to the following:
// '/e44d3b0d-b552-4257-8b64-a53331184c38/443061b9-bfa7-40fc-a5a9-d848bc52155e/4d818f4c-88b3-45fd-a104-a2fc3700e9de'
await blobStore . setCurrentBlobDir ( '/some/blob/path' ) ;
console . log ( await blobStore . getCurrentBlobDir ( ) ) ;
// Outputs '/some/blob/path' to the console.
// Any new blob files added to the blob store will go into this path until there are `dirWidth` or 2000 files within it.
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;createWriteStream()Type: méthode.
Renvoie : une Promise qui se résout vers un Object contenant le chemin d'enfant vers le fichier dans la racine du magasin Blob et un écriture écrit.
Description:
Voici une exampe de l'objet retourné en utilisant UUID comme idfunction:
{
blobPath : "/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19" ,
writeStream : stream . Writable
} Utilisez le writeStream pour enregistrer votre blob ou votre fichier. Le blobPath doit être enregistré dans votre base de données pour un accès futur.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
// The below readStream is simply to make this a complete example
const fs = require ( 'fs' ) ;
const readStream = fs . createReadStream ( '/path/to/file' ) ;
async function main ( ) {
let result ;
try {
result = await blobStore . createWriteStream ( ) ;
} catch ( err ) {
console . error ( err ) ;
}
console . dir ( result ) ;
// result object will be similar to this:
// {
// blobPath: "/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19",
// writeStream: [WriteStream]
// }
// Using a Promise to encapsulate the write asynchronous events.
await new Promise ( ( resolve , reject ) => {
result . writeStream . on ( 'finish' , ( ) => {
resolve ( ) ;
} ) ;
result . writeStream . on ( 'error' , reject ) ;
readStream . pipe ( result . writeStream ) ;
} ) ;
console . log ( blobPath ) ;
// Logs the blobPath. Save this in your database.
}
main ( ) ;write(data, writeOptions)Type: méthode.
Paramètre: data comme String , Buffer , TypedArray ou DataView .
Paramètre: writeOptions en tant Object .
writeOptions prend en charge une propriété d'encodage, de mode et de drapeau. Renvoie: une Promise qui se résout en une String .
blobPath qui doit être engagée dans votre base de données.Description:
Si vous disposez de données simples en mémoire plutôt que d'un flux de données, vous pouvez utiliser cette méthode pour stocker les données dans un fichier blob.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
const data = 'The quick brown fox jumps over the lazy dog.' ;
try {
const blobPath = await blobStore . write ( data ) ;
// The returned blobPath will look something like this:
// '/e44d3b0d-b552-4257-8b64-a53331184c38/443061b9-bfa7-40fc-a5a9-d848bc52155e/4d818f4c-88b3-45fd-a104-a2fc3700e9de'
// Save it to your database.
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;append(blobPath, data, appendOptions)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Paramètre: data comme une String ou Buffer .
Paramètre: appendOptions comme Object .
appendOptions prend en charge une propriété de codage, de mode et de drapeau. Renvoie: une Promise qui se résout à une undefined .
Description:
Utilisez cette méthode pour ajouter des données simples dans la mémoire à la fin du fichier blob.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
const data = 'The quick brown fox jumps over the lazy dog.' ;
try {
await blobStore . append ( data ) ;
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;copy(blobPath, flags)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Paramètre: flags en Number .
Renvoie: une Promise qui se résout en une String .
blobPath pour le fichier blob copié.Description:
Utilisez cette méthode pour créer une copie d'un fichier blob existant.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
const blobPathSource =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const blobPathDest = await blobStore . copy ( blobPathSource ) ;
// Store your new blobPath into your application database
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;createReadStream(blobPath)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Renvoie : une Promise qui se résout à un ReadStream .
Description:
Crée un flux lisible vers le fichier blob situé au blobPath .
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
async function main ( ) {
// Get the blobPath value from your database.
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19h' ;
let readStream ;
try {
readStream = await blobStore . createReadStream ( blobPath ) ;
} catch ( err ) {
console . error ( err ) ;
}
readStream . on ( 'error' , ( err ) => {
console . error ( err ) ;
} ) ;
// Blob contents is piped to the console.
readStream . pipe ( process . stdout ) ;
}
main ( ) ;read(blobPath, readOptions)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Paramètre: readOptions comme Object .
Renvoie: une Promise qui résout en un contenu du fichier blob.
scalable-blob-store définit la valeur readOptions.encoding à «UTF8» par défaut.Description:
Utilisez cette méthode pour lire le contenu d'un petit fichier blob en mémoire.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const content = await blobStore . read ( blobPath ) ;
// Do something with the content
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;open(blobPath, flags, mode)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Paramètre: flags en tant que String ou Number .
Renvoie: une Promise qui se résout en un objet FileHandle.
Description:
Il s'agit d'une méthode plus avancée vous permettant d'effectuer de nombreuses opérations de fichiers par rapport au fichier blob.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const fileHandle = await blobStore . open ( blobPath ) ;
// Do something with the file handle object
// See the documentation for more detail
// The documentation link is in the description above
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;realPath(blobPath, realPathOptions)Type: méthode.
Paramètre: blobPath comme String .
blobPath de votre base de données d'application. Paramètre: realPathOptions en tant que String ou Object .
Renvoie: une Promise qui se résout en une String .
Description:
Utilisez cette méthode pour localiser un fichier blob sur le système de fichiers. Cette méthode ne doit pas vraiment être nécessaire car vous pouvez déterminer le chemin complet du fichier blob. Concaténer simplement le BlobstoreRoot et les valeurs de Blobpath.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const fsPath = await blobStore . realPath ( blobPath ) ;
// With the above options the result will be similar to this:
// '/app/blobs/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;stat(blobPath)Type: méthode.
Paramètre: blobPath comme String .
Renvoie: un Object Statts.
Description:
Plutôt que d'analyser l'objet Système de fichiers stats , scalable-blob-store renvoie l'objet stats RAW.
Plus de détails sur la classe STAT peuvent être trouvés sur Wikipedia.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const stats = await blobStore . stat ( blobPath ) ;
console . dir ( stats ) ;
// Console output will be similar to the following.
// { dev: 2050,
// mode: 33188,
// nlink: 1,
// uid: 1000,
// gid: 1000,
// rdev: 0,
// blksize: 4096,
// ino: 6707277,
// size: 44,
// blocks: 8,
// atime: Mon Oct 12 2015 08:51:29 GMT+1000 (AEST),
// mtime: Mon Oct 12 2015 08:51:29 GMT+1000 (AEST),
// ctime: Mon Oct 12 2015 08:51:29 GMT+1000 (AEST),
// birthtime: Mon Oct 12 2015 08:51:29 GMT+1000 (AEST) }
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;exists(blobPath)Type: méthode.
Paramètre: blobPath comme String .
Retour: Boolean
true si le fichier existe, sinon false .Description:
Utilisez cette méthode pour un test d'existence de fichiers BLOB simple.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
const exists = await blobStore . exists ( blobPath ) ;
// The result will be either true or false depending if the blob file exists.
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ;remove(blobPath)Type: méthode.
Paramètre: blobPath comme String .
Renvoie : undefined si rien ne s'est mal passé ou si le fichier n'existait pas.
Description:
Utilisez cette méthode pour supprimer un fichier blob. Cette méthode ne peut pas être utilisée pour supprimer les répertoires.
Exemple:
const BlobStore = require ( 'scalable-blob-store' ) ;
const uuid = require ( 'uuid' ) ;
const options = {
blobStoreRoot : '/app/blobs' ,
idFunction : uuid . v4 ,
dirDepth : 3 ,
dirWidth : 2000 ,
} ;
const blobStore = new BlobStore ( options ) ;
async function main ( ) {
try {
// Retrieve the blobPath value from your database
const blobPath =
'/e6b7815a-c818-465d-8511-5a53c8276b86/aea4be6a-9e7f-4511-b394-049e68f59b02/fea722d1-001a-4765-8408-eb8e0fe7dbc6/183a6b7b-2fd6-4f80-8c6a-2647beb7bb19' ;
await blobStore . remove ( blobPath ) ;
// The blob file will no longer exist
} catch ( err ) {
console . error ( err ) ;
}
}
main ( ) ; Il y a un problème mineur dans scalable-blob-store . S'il y a un grand nombre de fichiers blob ajoutés puis supprimés du magasin Blob, vous pouvez avoir des répertoires ou des répertoires vides avec un petit nombre de fichiers. Ces répertoires ne seront jamais supprimés et ne seront pas peuplés.
Si vous souhaitez empêcher les répertoires vides ou peu peuplés, vous devrez exécuter une tâche de maintenance contre le répertoire blobStoreRoot . Cette tâche de maintenance devra rechercher des répertoires vides ou incomplets et appeler la méthode setCurrentBlobdir passant dans le blobPath vide.
Pour votre application, vous pouvez trouver rarement supprimer un grand nombre de fichiers blob. Si tel est le cas, ce problème peut être ignoré.
Il existe deux méthodes pour tester scalable-blob-store :
os.tmpdir() . Après le clonage scalable-blob-store , tapez ce qui suit dans votre console:
npm install
npm test
L'exécution du fichier test-fs.js créera un répertoire ~/blobs dans votre répertoire temporaire, puis le remplira récursivement de beaucoup de blobs.
Les options par défaut configurées dans le fichier test-fs.js sont:
const opts = {
blobStoreRoot : os . tmpdir ( ) + '/blobs' ,
idFunction : cuid ,
dirDepth : 3 ,
dirWidth : 1000 ,
} ;
const repeat = 10000 ;Modifiez les options si vous souhaitez voir différents résultats.
Après le clonage scalable-blob-store , tapez ce qui suit dans votre console:
npm install
node ./tests/test-fs.js
Une fois terminé, inspectez le répertoire /tmp/blobs . Je suggère d'utiliser la commande d'arbre qui vous donne un résumé des répertoires et des fichiers dans le répertoire cible.
tree ~ /blobs
tree -d ~ /blobs
Moi, Grant Carthew, je suis technologue du Queensland, en Australie. Je travaille sur du code dans un certain nombre de projets personnels et lorsque le besoin s'en fait sentir, je construis mes propres packages.
Ce projet existe parce que j'avais besoin d'un magasin blob local qui pourrait évoluer.
Tout ce que je fais en open source se fait à mon propre temps et en tant que contribution à la communauté open source.
Si vous utilisez mes projets et que vous souhaitez me remercier ou me soutenir, veuillez cliquer sur le lien Patreon ci-dessous.
Voir mes autres projets sur NPM.
git checkout -b my-new-featuregit commit -am 'Add some feature'git push origin my-new-featurenode-uuid par uuid .ES5 . Retirer les exigences du moteur NodeJS.return null .return null après résolution / rejeter les appels pour empêcher les avertissements de Bluebird.es5dist pour les anciennes versions du nœud. Packages mis à jour.Mit
