1. 简介

eclipse自动升级版本之后，在/eclipse/plugins目录仍然会保留旧版本的插件，想要写一个脚本清理插件，正好最近刚学习rust编程，便用rust开发了一个eclipse插件清理工具eclean。

本文简单介绍清理工具的开发过程，详细源代码可以在github下载并自行编译：

git clone https://github.com/leexgone/ecleaner.git
cd ./ecleaner
cargo build --release

工具支持清理eclipse升级后plugins目录下的冗余插件。

清理eclipse插件目录并将清理插件备份：

eclean c:\eclipse e:\backup\eclipse

检测eclipse目录下是否含有可清理的插件：

eclean -t c:\eclipse

更多命令可以查阅：

eclean --help

2.创建工程

使用cargo new elean创建工程，调整Cargo.toml内容并在src目录下创建lib.rs文件。

3.命令行参数解析

eclean是一个命令行工具，首先我们需要支持命令行参数的解析。

rust的clap库是一套功能强大的命令行参数解析库，这里我们使用clap解析命令行参数。

3.1 引用clap库

在Cargo.toml里加入clap依赖：

[dependencies]
clap = "2.33.3"

3.2 创建Config结构

编辑lib.rs代码，定义Config结构存储命令配置信息，使用clap解析命令参数：

use std::{collections::HashMap, error::Error, fs, io::{self, ErrorKind}, path::{Path, PathBuf}, usize};
use std::fmt::Display;

use clap::{App, Arg};

pub struct Config {
    dir: String,
    backup: String,
    verbose: bool,
    test: bool,
    force: bool,
}

impl Display for Config {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "[dir = {}, backup = {}, verbose = {}, test = {}, force = {}]", self.dir, self.backup, self.verbose, self.test, self.force)
    }
}

impl Config {
    pub fn new() -> Result<Config, String> {
        let matches = App::new("eclean")
                        .version("1.1.0")
                        .author("Steven Lee <leexgone@163.com>")
                        .about("Clean up the duplicated plugins in eclipse plugins directory.")
                        .arg(Arg::with_name("DIR")
                            .help("The eclipse root directory to be cleaned. The `/plugins` directory should be under this directory.")
                            .required(true)
                            .index(1))
                        .arg(Arg::with_name("BACKUP")
                            .help("Specify a backup directory to store the removed plugins.")
                            .required_unless("test")
                            .index(2))
                        .arg(Arg::with_name("verbose")
                            .short("v")
                            .long("verbose")
                            .help("Use verbose output"))
                        .arg(Arg::with_name("test")
                            .short("t")
                            .long("test")
                            .help("Scan and find the duplicated plugins, but do nothing"))
                        .arg(Arg::with_name("force")
                            .short("f")
                            .long("force")
                            .help("Clean up the duplicated plugins automatically. Never prompt."))
                        .get_matches();

        let dir = matches.value_of("DIR").unwrap();
        let backup = matches.value_of("BACKUP").unwrap_or("");
        let verbose = matches.is_present("verbose");
        let test = matches.is_present("test");
        let force = matches.is_present("force");

        let root_path = Path::new(dir);
        if !root_path.is_dir() {
            let msg = format!("DIR '{}' does not exist", dir);
            return Err(msg);
        }

        if !test {
            let backup_path = Path::new(backup);
            if !backup_path.is_dir() {
                let msg = format!("BACKUP dir '{}' does not exist", backup);
                return Err(msg);
            }
        }

        Ok(Config {
            dir: String::from(dir),
            backup: String::from(backup),
            verbose,
            test,
            force,
        })
    }
}

Config结构存储了用户参数命令的配置信息：

dir：eclipse目录（必须）
backup: 清理插件备份目录（必须，在test模式下可以忽略）
verbose：输出详细日志
test：仅检测eclipse插件目录，不执行清理操作
force：不询问用户强制清理插件

这里我们对用户的输入进行了检测，在目录不存在时提示错误；而必须参数的校验则通过clap完成即可。

3.3 调整main代码

在main.rs中加入参数命令的解析代码：

use std::process;

use eclean::Config;

fn main() {
    let  config = Config::new().unwrap_or_else(|err| {
        eprintln!("Error when parsing arguments: {}.", err);
        process::exit(1);
    });

    // ...
}

3.4 测试效果

PS E:\GitHub\ecleaner> cargo build
    Finished dev [unoptimized + debuginfo] target(s) in 0.14s
PS E:\GitHub\ecleaner> .\target\debug\eclean.exe --help
eclean 1.1.0
Steven Lee <leexgone@163.com>
Clean up the duplicated plugins in eclipse plugins directory.

USAGE:
    eclean.exe [FLAGS] <DIR> <BACKUP>

FLAGS:
    -h, --help       Prints help information
    -t, --test       Scan and find the duplicated plugins, but do nothing
    -V, --version    Prints version information
    -v, --verbose    Use verbose output

ARGS:
    <DIR>       The eclipse root directory to be cleaned. The `/plugins` directory should be under this directory.
    <BACKUP>    Specify a backup directory to store the removed plugins.
PS E:\GitHub\ecleaner> .\target\debug\eclean.exe d:/eclipse
error: The following required arguments were not provided:
    <BACKUP>

USAGE:
    eclean.exe [FLAGS] <DIR> <BACKUP>

For more information try --help
PS E:\GitHub\ecleaner>

4. 版本号识别

4.1 eclipse版本号

我们观察eclipse插件的版本号，由4部分构成：major.minor.patch.build:

major：主版本号
minor：子版本号
patch：补丁版本号
build：构建版本号，可忽略

例如：org.apache.axis1.4.0.v201411182030，org.eclipse.core.runtime3.20.0.v20201027-1526.jar。

这里，我们设计Version结构存储版本信息，因为部分插件没有提供build版本号，我们使用Option<String>存储。

pub struct Version {
    pub major: usize,
    pub minor: usize,
    pub patch: usize,
    pub build: Option<String>,
}

4.2 Version实现

在清理插件时，我们需要对多个版本的插件版本进行排序，这里我们通过Version实现排序trait来实现。

为支持排序，Version结构体需要实现Eq、Ord、PartialEq和PartialOrd四个trait。

Version的解析方法比较简单，通过字符串的分隔即可实现，这里我们仅实现版本号字符串的解析，整体插件名称的解析在后面处理。

我们在工程里增加version.rs文件，编写Version结构体代码：

use std::{error::Error, fmt::Display};

#[derive(Debug)]
#[derive(Eq)]
pub struct Version {
    pub major: usize,
    pub minor: usize,
    pub patch: usize,
    pub build: Option<String>,
}

impl Version {
    pub fn new(major: usize, minor: usize, patch: usize, build: Option<&str>) -> Version {
        Version {
            major,
            minor,
            patch,
            build: if let Some(text) = build {
                Some(String::from(text))
            } else {
                None
            }
        }
    }

    pub fn parse(expr: &str) -> Result<Version, Box<dyn Error>> {
        let mut version = Version {
            major: 0,
            minor: 0,
            patch: 0,
            build: None,
        };

        for (i, val) in expr.split('.').enumerate() {
            match i {
                0 => {
                    version.major = val.parse()?;
                }
                1 => {
                    version.minor = val.parse()?;
                }
                2 => {
                    version.patch = val.parse()?;
                }
                3 => {
                    version.build = Some(String::from(val));
                }
                _ => {
                }
            }
        };

        Ok(version)
    }
}

impl Display for Version {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(suffix) = self.build.as_ref() {
            write!(f, "{}.{}.{}.{}", self.major, self.minor, self.patch, suffix)
        } else {
            write!(f, "{}.{}.{}", self.major, self.minor, self.patch)
        }
    }
}

impl Ord for Version {
    fn cmp(&self, other: &Self) -> std::cmp::Ordering {
        let ret = self.major.cmp(&other.major);
        if ret != std::cmp::Ordering::Equal {
            return ret;
        }

        let ret = self.minor.cmp(&other.minor);
        if ret != std::cmp::Ordering::Equal {
            return ret;
        }

        let ret = self.build.cmp(&other.build);
        if ret != std::cmp::Ordering::Equal {
            return ret;
        }

        let self_build = if let Some(build) = self.build.as_ref() {
            build
        } else {
            ""
        };

        let other_build = if let Some(build) = other.build.as_ref() {
            build
        } else {
            ""
        };

        self_build.cmp(other_build)
    }
}

impl PartialOrd for Version {
    fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for Version {
    fn eq(&self, other: &Self) -> bool {
        self.cmp(other) == std::cmp::Ordering::Equal
    }
}

4.3 模块声明

因为我们引入了一个新的源代码文件version.rs，为保证编译通过，需要在lib.rs文件开头增加如下声明：

mod version;

5.插件识别

eclipse的插件有两种形式：

以目录形式打包的插件，目录名类似org.apache.ant_1.10.9.v20201106-1946
以JAR包形式打包的插件，文件名类似org.eclipse.core.runtime_3.20.0.v20201027-1526.jar

所有的插件命名以plugin-name_version-expr的形式命名，为进行插件的扫描和比较，我们需要记录插件的标识和版本号；此外，还需要记录插件的目录或文件名，以用于后续的清理操作。

5.1 Plugin结构

创建plugin.rs源代码文件，声明Plugin结构体：

pub struct Plugin {
    pub path: PathBuf,
    pub name: String,
    pub version: Version,
}

在lib.rs中增加plugin模块声明：

mod plugin;

5.2 解析插件

要解析插件的名称和版本号，需要将插件文件名（目录名）拆分，因为插件名称和版本号中都可能含有_符号，这里不能简单的使用字符分隔。

在这里我们需要使用正则表达式进行识别，首先引入rust的regex库，在Cargo.toml里增加插件引用：

[dependencies]
regex = "1.4.3"

然后修改plugin.rs中的代码，Plugin::new()函数实现解析代码，解析时我们需要区分目录和文件的插件形式。

use std::{error::Error, fmt::Display, fs, io::ErrorKind, path::PathBuf, usize};

use regex::Regex;

use super::version::Version;

#[derive(Debug)]
pub struct Plugin {
    pub path: PathBuf,
    pub name: String,
    pub version: Version,
}

impl Display for Plugin {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}({})", self.name, self.version)
    }
}

macro_rules! return_err {
    ($msg:expr) => {
        {
            let e = std::io::Error::new(ErrorKind::Other, $msg);
            return Err(Box::new(e));
        }
    }
}

impl Plugin {
    pub fn new(path: PathBuf) -> Result<Plugin, Box<dyn Error>> {
        let filename: String;
        let name = if path.is_file() {
            path.file_stem()
        } else {
            path.file_name()
        };

        match name {
            Some(stem) => {
                filename = String::from(stem.to_str().unwrap());
            },
            None => {
                return_err!(format!("Error parsing plugin: {}", path.display()));
            }
        }

        let regex = Regex::new("_\\d+[.]\\d+[.]\\d+")?;
        let (name, version) = if let Some(m) = regex.find(&filename) { 
            let plugin_name = &filename[0..m.start()];
            let version_expr = &filename[m.start() + 1..];
            match Version::parse(version_expr) {
                Ok(version) => {
                    (
                        String::from(plugin_name),
                        version,
                    )
                },
                Err(e) => {
                    return_err!(format!("Error parsings plugin `{}`: {}", path.display(), e));
                }
            }
        } else {
            (
                filename, 
                Version::new(0, 0, 0, None)
            )
        };

        Ok(Plugin {
            path,
            name,
            version
        })
    }
}

其中，我们定义了return_err宏简化异常处理

5.3 插件操作

重复插件清理时，需要将插件从/eclipse/plugins目录移动到备份目录中，我们为Plugin结构体提供move_to()方法实现插件迁移。由于插件可能是目录形式，使用递归的方式进行移动。

impl Plugin {
    pub fn move_to(&self, target: &PathBuf) -> Result<usize, Box<dyn Error>> {
        let count = Plugin::copy_all(&self.path, target)?;

        self.remove()?;

        Ok(count)
    }

    fn copy_all(root: &PathBuf, target: &PathBuf) -> Result<usize, Box<dyn Error>> {
        let mut count: usize = 0;
        let mut dest_path = target.clone();
        dest_path.push(root.file_name().unwrap());

        if root.is_file() {
            fs::copy(&root, &dest_path)?;

            count += 1;
        } else if root.is_dir() {
            if !dest_path.exists() {
                fs::create_dir(&dest_path)?;
            }

            for entry in root.read_dir()? {
                let entry = entry?;
                let sub_path = entry.path();

                count += Plugin::copy_all(&sub_path, &dest_path)?;
            }
        }

        Ok(count)
    }

    fn remove(&self) -> Result<(), Box<dyn Error>> {
        if self.path.is_file() {
            fs::remove_file(&self.path)?;
        } else if self.path.is_dir() {
            fs::remove_dir_all(&self.path)?;
        }

        Ok(())
    }
}

6.插件清理

6.1 插件扫描

要清理重复的插件，首先需要对eclipse的所有插件进行扫描，我们定义PluginSet结构体存储插件并封装清理操作，使用哈希表来存储扫描后的插件。

修改lib.rs代码，增加PluginSet定义与实现：


macro_rules! log {
    ($enabled:expr) => {
        {if $enabled { println!(); }}
    };
    ($enabled:expr, $($arg:tt)*) => {
        {if $enabled { println!($($arg)*); }}
    };
}

#[derive(Debug)]
struct PluginSet {
    plugins: HashMap<String, Vec<Plugin>>,
}

impl PluginSet {
    fn new(dir: &str, verbose: bool) -> Result<PluginSet, Box<dyn Error>> {
        let plugin_path = PathBuf::from(format!("{}/plugins", dir));
        if !plugin_path.is_dir() { 
            let e = std::io::Error::new(ErrorKind::NotFound, format!("Can not find `plugins` dir under `{}` dir", dir));
            return Err(Box::new(e));
        }

        let mut plugins: HashMap<String, Vec<Plugin>> = HashMap::new();

        log!(verbose, "Search plugins under dir `{}`...", plugin_path.display());
        for entry in plugin_path.read_dir()? {
            let entry = entry?;
            let path = entry.path();
            let plugin = Plugin::new(path)?;

            log!(verbose, ">> {}", plugin);
            if let Some(list) = plugins.get_mut(&plugin.name) {
                list.push(plugin);
            } else {
                plugins.insert(plugin.name.clone(), vec![plugin]);
            }
        }

        for list in plugins.values_mut() {
            list.sort_by(|a, b| a.version.cmp(&b.version));
        }

        Ok(PluginSet { plugins })
    }

    fn find_duplicates(&self) -> Vec<&Vec<Plugin>> {
        self.plugins.values().filter(|list| list.len() > 1).collect()
    }

    fn print_dupicates(duplicates: &Vec<&Vec<Plugin>>) {
        println!("{} duplicated plugins found:", duplicates.len());
        for (i, list) in duplicates.iter().enumerate() {
            let id = i + 1;
            let plugins = *list;

            let keep = plugins.last().unwrap();
            print!("  {}\t{} [KEEP: {}; DISCARD: ", id, keep.name, keep.version);

            for (p, plugin) in plugins.iter().enumerate() {
                if p == plugins.len() - 1 {
                    break;
                }

                if p > 0 {
                    print!(", ");
                }

                print!("{}", plugin.version);
            }
            println!("]");
        }
    }

    fn remove_duplicates(duplicates: &Vec<&Vec<Plugin>>, backup: &str, verbose: bool) -> Result<(), Box<dyn Error>> {
        let backup_path: PathBuf = [backup, "plugins"].iter().collect();

        if !backup_path.exists() {
            fs::create_dir(&backup_path)?;
            log!(verbose, "Create backup dir: {}", backup_path.display());
        }

        let mut count = 0;
        for list in duplicates {
            let plugins = *list;

            let keep = plugins.last().unwrap();
            log!(verbose, "Cleaning up `{}`, lastest: v{}...", keep.name, keep.version);

            for (i, plugin) in plugins.iter().enumerate() {
                if i == plugins.len() - 1 {
                    break;
                }

                let file_count = plugin.move_to(&backup_path)?;
                log!(verbose, "  remove version v{}, {} files deleted.", plugin.version, file_count);

                count += 1;
            }
        }

        println!("{} plugins have been cleaned up successfully!", count);

        Ok(())
    }
}

其中：

new()方法扫描指定的eclipse目录，识别所有插件并创建PluginSet
find_duplicates()方法过滤存在重复版本的插件列表
print_dupicates()方法打印存在重复版本的插件信息
remove_duplicates()方法执行清理，将旧版本插件移动到备份目录中

6.2 执行清理

在lib.rs中增加插件清理方法：

pub fn run(config: Config) -> Result<(), Box<dyn Error>> {
    let plugin_set = PluginSet::new(&config.dir, config.verbose)?;
    let duplicates = plugin_set.find_duplicates();

    if duplicates.is_empty() {
        println!("There are no duplidated plugins.")
    } else {
        PluginSet::print_dupicates(&duplicates);
        if !config.test {
            if config.force || prompt(duplicates.len()) {
                PluginSet::remove_duplicates(&duplicates, &config.backup, config.verbose)?;
            }
        }
    }

    Ok(())
}

fn prompt(size: usize) -> bool {
    println!("{} plugins will be removed to the backup dir. Continue to remove these plugins? [Y/n] ", size);

    let mut answer = String::new();
    io::stdin().read_line(&mut answer).expect("Invalidate input");
    let answer = answer.trim();

    "Y".eq_ignore_ascii_case(answer) || "YES".eq_ignore_ascii_case(answer)
}

最后，我们调整main.rs，完成所有实现：

use std::process;

use eclean::Config;

fn main() {
    let  config = Config::new().unwrap_or_else(|err| {
        eprintln!("Error when parsing arguments: {}.", err);
        process::exit(1);
    });

    if let Err(e) = eclean::run(config) {
        eprintln!("Error when cleaning up: {}", e);
        process::exit(2);
    }
}

7. 总结

我们使用rust开发了一个eclean工具，开发过程中使用了clap和regex库。

rust语言学习入门有一定的难度，但掌握之后开发效率还是比较高效的，编译的程序体积小又易于跨平台使用，还是一门很不错的语言的。

用Rust清理eclipse自动升级后的重复插件

1. 简介

2.创建工程

3.命令行参数解析

3.1 引用clap库

3.2 创建Config结构

3.3 调整main代码

3.4 测试效果

4. 版本号识别

4.1 eclipse版本号

4.2 Version实现

4.3 模块声明

5.插件识别

5.1 Plugin结构

5.2 解析插件

5.3 插件操作

6.插件清理

6.1 插件扫描

6.2 执行清理

7. 总结

相关推荐

idea本地配置连接远程hadoop集群的一些网络问题解决汇总

无缓存不行?例行升级的入门级阿斯加特AN2 SSD装机点评

Ceph运维手册(基于P版本)

大数据开发前要做什么准备?8台Hadoop服务器进行集群规划前配置

Tensorflow分类loss函数总结 tensorflow绘制loss曲线

R语言学习笔记(七) -离散型数据的模型预测2

iOS Runtime详解

7 个对 Java 意义重大的性能指标，你知道几个?

Laravel框架使用图片处理简单教程

PHP 远程调试最佳实践