filesysteminfile

9 min

El filesysteminfile le permite crear y actualizar sistemas de archivos para usarlos como dispositivos de almacenamiento.

IDL de filesysteminfile

interface FileSystemInFile {
    constructor(String path);
    Promise<String> getFilename();
    Promise<long long> getSize();
    Promise<void> format(String fileSystem);
    Promise<void> mount();
    Promise<void> unmount();
};

Creación de objetos

Para crear un objeto filesysteminfile, cargue el módulo @brightsign/filesysteminfile usando el método require() de Node.js®:

var FileSystemInFile = require('@brightsign/filesysteminfile');
var fsif = new FileSystemInFile("/storage/sd/usbstore.img"); // Node's native 'fs' can create an .img file

filesysteminfile

Use esta interfaz para configurar un filesysteminfile.

getFilename()

Promise<String> getFilename()

Obtiene el nombre del archivo que se utilizó para crear FileSystemInFile.

getSize()

Promise<long long> getSize()

Recupera el tamaño (en bytes) del archivo del sistema de archivos utilizado para crear la clase FileSystemInFile.

format()

Promise<void> format(String fileSystem)

Crea el sistema de archivos especificado en un archivo que ya existe. Los tipos de sistemas de archivos compatibles son "fat" y "exfat".

mount()

Promise<String> mount()

Monta el sistema de archivos. No es necesario formatear el sistema de archivos si ya existe y está formateado.

La cadena devuelta es filepath y el valor devuelto es la ruta donde se ha montado el sistema de archivos. No puede montarse más de una vez.

unmount()

Promise<void> unmount()

Desmonta el sistema de archivos.

Ejemplo

El siguiente ejemplo crea un sistema de archivos, lo formatea, lo monta y lo desmonta usando el paquete npm fs,

const fs = require('fs');
const FileSystemInFile = require('@brightsign/filesysteminfile');

var fsif;
var fd;

open()
.then(function(fileDescriptor) {
	fd = fileDescriptor;
	return write(fd);
})
.then(function(bytes) {
	console.log(`${bytes} written to new file`);
	return close(fd);
})
.then(function() {
	// Create FileSystemInFile using the backing file
	fsif = new FileSystemInFile('/storage/sd/usbstore');

	return format();
})
.then(function() {
	return mount();
})
.then(function() {
	/* This is where you can actually do stuff with the mounted filesystem. */

	// Unmount the mounted file after 10 seconds
	setTimeout(function() {
		return unmount();
	}, 10000);
})
.catch(function(error) {
	console.log(JSON.stringify(error));
});


// Create a writable file for the file system
function open() {
	return new Promise(function(resolve, reject) {
		fs.open('/storage/sd/usbstore', 'w', function(error, fd) {
			if (error) reject(error);
			resolve(fd);
		});	
	});
};

// Write a buffer allocating 1GB of disk space for the file
function write(fd) {
	return new Promise(function(resolve, reject) {
		fs.write(fd, Buffer.alloc(1), 0, 1, (1024*1024*1024) - 1, function(error, bytesWritten) {
			if (error) reject(error);
			resolve(bytesWritten);
		});
	});
};

// Close the created file
function close(fd) {
	return new Promise(function(resolve, reject) {
		fs.close(fd, function(error) {
			if (error) reject(error);
			resolve();
		});
	});
};

// Format the file system
function format() {
	return new Promise(function(resolve, reject) {
		fsif.format("exfat")
		.then(function() {
		  console.log('Filesystem formatted');
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});		
	});
};


// Mount the filesystem internally
function mount() {
	return new Promise(function(resolve, reject) {
		fsif.mount()
		.then(function(mount_point) {
		  console.log('Filesystem mounted' + mount_point);
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});
	});
};

// Unmount filesystem from internal mount point. Only can unmount a mounted file
function unmount() {
	return new Promise(function(resolve, reject) {
		fsif.unmount()
		.then(function() {
		  console.log('Filesystem unmounted');
		  resolve();
		})
		.catch(function(error) {
		  reject(error);
		});
	});
};

También puede consultar nuestro ejemplo de github público que utiliza un dispositivo BrightSign como sistema de archivos a través de USB.