Struct Tool 

pub struct Tool {
    pub context: ToolContext,
    pub locator: Option<PluginLocator>,
    pub metadata: RegisterToolOutput,
    pub plugin: Arc<PluginContainer>,
    pub proto: Arc<ProtoEnvironment>,
    pub ty: PluginType,
    pub version: Option<VersionSpec>,
    pub inventory: Inventory,
    pub product: Product,
    /* private fields */
}

Fields

context: ToolContext

locator: Option<PluginLocator>

metadata: RegisterToolOutput

plugin: Arc<PluginContainer>

proto: Arc<ProtoEnvironment>

ty: PluginType

version: Option<VersionSpec>

inventory: Inventory

product: Product

Implementations

impl Tool

pub async fn detect_version(&self) -> Result<ToolSpec, ProtoDetectError>

pub async fn detect_version_from( &self, current_dir: &Path, ) -> Result<Option<(UnresolvedVersionSpec, PathBuf)>, ProtoDetectError>

Attempt to detect a version from the provided directory by scanning for applicable files.

impl Tool

pub fn is_installed(&self) -> bool

Return true if the tool has been installed. This is less accurate than is_setup, as it only checks for the existence of the inventory directory.

pub async fn verify_checksum( &self, checksum_file: &Path, download_file: &Path, checksum_public_key: Option<&str>, ) -> Result<Checksum, ProtoInstallError>

Verify the downloaded file using the checksum strategy for the tool. Common strategies are SHA256 and MD5.

pub async fn install( &mut self, options: InstallOptions, ) -> Result<Option<LockRecord>, ProtoInstallError>

Install a tool into proto, either by downloading and unpacking a pre-built archive, or by using a native installation method.

pub async fn uninstall(&self) -> Result<bool, ProtoInstallError>

Uninstall the tool by deleting the current install directory.

impl Tool

pub async fn generate_shims( &mut self, force: bool, ) -> Result<(), ProtoLinkError>

Create shim files for the current tool if they are missing or out of date. If find only is enabled, will only check if they exist, and not create.

pub async fn symlink_bins(&mut self, force: bool) -> Result<(), ProtoLinkError>

Symlink all primary and secondary binaries for the current tool.

impl Tool

pub async fn resolve_primary_exe_location( &self, ) -> Result<Option<ExecutableLocation>, ProtoLocateError>

Return location information for the primary executable within the tool directory.

pub async fn resolve_secondary_exe_locations( &self, ) -> Result<Vec<ExecutableLocation>, ProtoLocateError>

Return location information for all secondary executables within the tool directory.

pub async fn resolve_bin_locations( &mut self, include_all_versions: bool, ) -> Result<Vec<ExecutableLocation>, ProtoLocateError>

Return a list of all binaries that get created in ~/.proto/bin. The list will contain the executable config, and an absolute path to the binaries final location.

pub async fn resolve_bin_locations_with_manager( &mut self, bin_manager: BinManager, include_all_versions: bool, ) -> Result<Vec<ExecutableLocation>, ProtoLocateError>

pub async fn resolve_shim_locations( &self, ) -> Result<Vec<ExecutableLocation>, ProtoLocateError>

Return a list of all shims that get created in ~/.proto/shims. The list will contain the executable config, and an absolute path to the shims final location.

pub fn get_exe_file(&self) -> Option<&Path>

Return an absolute path to the primary executable file, after it has been located.

pub async fn locate_exe_file(&mut self) -> Result<PathBuf, ProtoLocateError>

Locate the primary executable from the tool directory.

pub fn get_exes_dir(&self) -> Option<&Path>

Return an absolute path to the primary executables directory (first in the list), after it has been located.

pub fn get_exes_dirs(&self) -> &[PathBuf]

Return an absolute path to all executable directories, after they have been located.

pub async fn locate_exes_dirs( &mut self, ) -> Result<Vec<PathBuf>, ProtoLocateError>

Locate the directory that local executables are installed to.

pub fn get_globals_dir(&self) -> Option<&Path>

Return an absolute path to the globals directory, after it has been located.

pub async fn locate_globals_dir( &mut self, ) -> Result<Option<PathBuf>, ProtoLocateError>

Return an absolute path to the globals directory that actually exists and contains files (executables).

pub fn get_globals_dirs(&self) -> &[PathBuf]

Return an absolute path to all globals directories, after they have been located.

pub async fn locate_globals_dirs( &mut self, ) -> Result<Vec<PathBuf>, ProtoLocateError>

Locate the directories that global packages are installed to. Will expand environment variables, and filter out invalid paths.

pub fn get_globals_prefix(&self) -> Option<&str>

Return the globals prefix, after it has been located.

pub async fn locate_globals_prefix( &mut self, ) -> Result<Option<String>, ProtoLocateError>

Return a string that all globals are prefixed with. Will be used for filtering and listing.

impl Tool

pub fn insert_record_into_lockfile( &self, record: &LockRecord, ) -> Result<(), ProtoLockError>

pub fn remove_from_lockfile(&self) -> Result<(), ProtoLockError>

pub fn remove_version_from_lockfile( &self, version: &VersionSpec, ) -> Result<(), ProtoLockError>

pub fn get_resolved_locked_record(&self) -> Option<&LockRecord>

pub fn resolve_locked_record( &self, spec: &ToolSpec, ) -> Result<Option<LockRecord>, ProtoLockError>

pub fn verify_locked_record( &self, install_record: &LockRecord, ) -> Result<(), ProtoLockError>

Verify the installation is legitimate by comparing it to the internal lockfile record.

impl Tool

pub async fn load_version_resolver( &self, initial_version: &UnresolvedVersionSpec, ) -> Result<VersionResolver<'_>, ProtoResolveError>

Load available versions to install and return a resolver instance. To reduce network overhead, results will be cached for 24 hours.

pub async fn resolve_version( &mut self, spec: &ToolSpec, short_circuit: bool, ) -> Result<VersionSpec, ProtoResolveError>

Given an initial spec, resolve it to a fully qualifed and semantic version (or alias) according to the tool’s ecosystem.

pub async fn resolve_version_candidate( &self, resolver: &VersionResolver<'_>, initial_candidate: &UnresolvedVersionSpec, with_manifest: bool, ) -> Result<VersionSpec, ProtoResolveError>

impl Tool

pub async fn is_setup( &mut self, spec: &ToolSpec, ) -> Result<bool, ProtoSetupError>

Return true if the tool has been setup (installed and executables are located).

pub async fn setup( &mut self, spec: &ToolSpec, options: InstallOptions, ) -> Result<Option<LockRecord>, ProtoSetupError>

Setup the tool by resolving a semantic version, installing the tool, locating binaries, creating shims, and more.

pub async fn teardown( &mut self, spec: &ToolSpec, ) -> Result<bool, ProtoSetupError>

Teardown the tool by uninstalling the current version, removing the version from the manifest, and cleaning up temporary files. Return true if the teardown occurred.

pub async fn cleanup(&mut self) -> Result<(), ProtoSetupError>

Delete temporary files and downloads for the current version.

pub async fn sync_manifest(&mut self) -> Result<(), ProtoSetupError>

Sync the local tool manifest with changes from the plugin.

impl Tool

pub async fn new( context: ToolContext, proto: Arc<ProtoEnvironment>, plugin: Arc<PluginContainer>, ) -> Result<Tool, ProtoToolError>

pub async fn load<I, P>( context: I, proto: P, wasm: Wasm, ) -> Result<Tool, ProtoToolError>

where I: AsRef<ToolContext> + Debug, P: AsRef<ProtoEnvironment>,

pub async fn load_from_manifest<I, P>( context: I, proto: P, manifest: Manifest, ) -> Result<Tool, ProtoToolError>

where I: AsRef<ToolContext>, P: AsRef<ProtoEnvironment>,

pub fn create_plugin_manifest<P>( proto: P, wasm: Wasm, ) -> Result<Manifest, ProtoToolError>

where P: AsRef<ProtoEnvironment>,

pub fn disable_caching(&mut self)

Disable internal caching when applicable.

pub fn get_backend(&self) -> Option<&Id>

Return the backend identifier.

pub fn get_env_var_prefix(&self) -> String

Return the prefix for environment variable names.

pub fn get_file_name(&self) -> &str

Return the tool identifier for use within file names.

pub fn get_id(&self) -> &Id

Return the tool identifier.

pub fn get_inventory_dir(&self) -> &Path

Return an absolute path to the tool’s inventory directory. The inventory houses installed versions, the manifest, and more.

pub fn get_name(&self) -> &str

Return a human readable name for the tool.

pub fn get_resolved_version(&self) -> VersionSpec

Return the resolved version or “latest”.

pub fn get_temp_dir(&self) -> &Path

Return an absolute path to a temp directory solely for this tool.

pub fn get_product_dir(&self) -> &Path

Return an absolute path to the tool’s install directory for the currently resolved version.

pub async fn is_backend_plugin(&self) -> bool

Return true if this tool instance is a backend plugin.

pub fn set_version(&mut self, version: VersionSpec)

Explicitly set the version to use.

pub fn from_virtual_path(&self, path: impl AsRef<Path> + Debug) -> PathBuf

Convert a virtual path to a real path.

pub fn to_virtual_path(&self, path: impl AsRef<Path> + Debug) -> VirtualPath

Convert a real path to a virtual path.

impl Tool

pub fn create_plugin_context(&self) -> PluginContext

Return contextual information to pass to WASM plugin functions.

pub fn create_plugin_unresolved_context(&self) -> PluginUnresolvedContext

Return contextual information to pass to WASM plugin functions, representing an unresolved state, which has no version or tool data.

pub fn create_locked_record(&self) -> LockRecord

Create an initial lock record.

pub async fn register_tool(&mut self) -> Result<(), ProtoToolError>

Register the tool by loading initial metadata and persisting it.

pub async fn register_backend(&mut self) -> Result<(), ProtoToolError>

Register the backend by acquiring necessary source files.

Trait Implementations

impl Debug for Tool

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.