const FormatReaders = require("./formats/read");
const FormatWriters = require("./formats/write");
const NetworkClient = require("./network");
const Repository = require("./repository");
const { Util } = require('../core/util');
/**
* pluginTypes describe the types of DART plugins.
*
* - FormatReader reads files of a specific format. For example,
* TarReader reads tar files and FileSystemReader reads files directly
* from the file system.
* - FormatWriter writes files in a specific format. For example,
* TarReader writes tar files and FileSystemReader writes files directly
* to the file system.
* - NetworkClient sends (and possibly retrieves) files across a network.
* For example, S3Client can upload files to any service that implements
* the S3 REST API. FTPClient (when someone writes it) can upload files
* to an FTP server.
* - Repository services can query different types of repositories. For
* example, an APTrust repository plugin can tell you the status of objects
* uploaded to APTrust. A Fedora plugin (if someone writes one) could do the
* same by talking to a Fedora REST service.
*
*/
const pluginTypes = ['FormatReader', 'FormatWriter', 'NetworkClient', 'Repository'];
/**
* PluginManager keeps track of available plugins and helps the DART core find
* the plugins it needs to complete a job. For example, if a job requires that
* we packaged a bag into a tar file and then send it via FTP to some remote
* server, the plugin manager will find the plugins capable of writing tar files
* and talking to FTP servers.
*
*/
class PluginManager {
/**
* This returns a list of plugin types. E.g. 'FormatReader',
* 'FormatWriter', etc.
*
* @returns {Array<string>}
*/
static types() {
return pluginTypes;
}
/**
* This returns a list of available plugins of the specified
* type. This function is primarily meant for internal use.
*
* @returns {Array<Plugin>}
*/
static getModuleCollection(type) {
var modules;
switch (type) {
case 'FormatReader':
modules = FormatReaders.Providers;
break;
case 'FormatWriter':
modules = FormatWriters.Providers;
break;
case 'NetworkClient':
modules = NetworkClient.Providers;
break;
case 'Repository':
modules = Repository.Providers;
break;
default:
throw `Param 'type' must be one of: Array.join(pluginTypes, ', ')`;
}
return modules;
}
/**
* This returns the plugin with the specified id.
*
* @returns {Plugin}
*/
static findById(id) {
for (var pluginType of pluginTypes) {
var modules = PluginManager.getModuleCollection(pluginType);
for (var module of modules) {
if (module.description().id == id) {
return module;
}
}
}
return null;
}
/**
* This returns a list of all plugins that can read the specified
* file extension. For example, canRead('.tar') returns a list of
* plugins that can read tar files. Use 'filesystem' if you're
* looking for plugins that can read from the file system.
*
* @param {string} fileExtension - A string specifying the extension
* of the file type you want to read. This should be all lowercase,
* such as '.tar', '.zip', etc.
*
* @returns {Array<Plugin>}
*/
static canRead(fileExtension) {
return PluginManager.pluginProvides('FormatReader', 'readsFormats', fileExtension)
}
/**
* This returns a list of all plugins that can write the specified
* file extension. For example, canWrite('.tar') returns a list of
* plugins that can write tar files. Use 'filesystem' if you're
* looking for plugins that can write to the file system.
*
* @param {string} fileExtension - A string specifying the extension
* of the file type you want to write. This should be all lowercase,
* such as '.tar', '.zip', etc.
*
* @returns {Array<Plugin>}
*/
static canWrite(fileExtension) {
return PluginManager.pluginProvides('FormatWriter', 'writesFormats', fileExtension)
}
/**
* This returns a list of all plugins that implement the specified
* network protocol. For example, implementsProtocol('s3') returns a
* list of plugins that can talk to s3 servers.
*
* @param {string} protocol - A string specifying what network protocol
* you want to use. This should be all lowercase, such as 'ftp', 'sftp',
* 's3', etc.
*
* @returns {Array<Plugin>}
*/
static implementsProtocol(proto) {
return PluginManager.pluginProvides('NetworkClient', 'implementsProtocols', proto)
}
/**
* This returns a list of all plugins that can talk to repositories
* of the specified type. For example, talksTo('fedora') returns a
* list of plugins that can talk to Fedora REST services.
*
* @param {string} repoType - A string specifying what kind of repository
* you want to talk to. This should be all lowercase, such as 'aptrust',
* 'fedora', etc.
*
* @returns {Array<Plugin>}
*/
static talksTo(repoType) {
return PluginManager.pluginProvides('Repository', 'talksToRepository', repoType)
}
/**
* This returns a list of plugins that provide a certain service,
* such as being able to read a specified format or communicate via a
* specific network protocol. This function is used internally by the
* convenience functions {@link canRead}, {@link canWrite},
* {@link implementsProtocol}, {@link talksTo}, and {@link setsUp}.
* You should generally use those functions instead of this one.
*
* @returns {Array<Plugin>}
*/
static pluginProvides(pluginType, propertyToCheck, valueToFind) {
var modules = PluginManager.getModuleCollection(pluginType);
var providers = [];
for (var module of modules) {
var desc = module.description();
if (Array.isArray(desc[propertyToCheck]) && desc[propertyToCheck].includes(valueToFind)) {
providers.push(module);
} else if (desc[propertyToCheck] === valueToFind) {
providers.push(module);
}
}
return providers;
}
}
module.exports.PluginManager = PluginManager;