uvm-install2 0.13.0

Install specified unity version.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use crate::error::*;
use crate::install::error::InstallerResult;
use crate::install::installer::{
    Installer, InstallerWithDestinationAndOptionalCommand, InstallerWithOptionalCommand,
};
use crate::install::{InstallHandler, UnityEditor, UnityModule};
use crate::*;
use std::fs;
use std::io::Write;
use std::path::Path;
use tempfile::Builder;
use thiserror_context::Context;

pub struct Exe;
pub type EditorExeInstaller =
    Installer<UnityEditor, Exe, InstallerWithDestinationAndOptionalCommand>;
pub type ModuleExeTargetInstaller =
    Installer<UnityModule, Exe, InstallerWithDestinationAndOptionalCommand>;
pub type ModuleExeInstaller = Installer<UnityModule, Exe, InstallerWithOptionalCommand>;

impl<V> InstallHandler for Installer<V, Exe, InstallerWithDestinationAndOptionalCommand> {
    fn install_handler(&self) -> InstallerResult<()> {
        let installer = self.installer();
        let destination = self.destination();

        debug!("install api from installer exe");
        let mut install_helper = Builder::new().suffix(".cmd").rand_bytes(20).tempfile()?;

        info!(
            "create install helper script {}",
            install_helper.path().display()
        );

        {
            let script = install_helper.as_file_mut();
            let parameter_option = match self.cmd() {
                Some(parameters) => parameters,
                _ => "/S",
            };

            let destination_option = format!("/D={}", destination.display());

            let install_command = format!(
                r#"CALL "{installer}" {parameters} {destination}"#,
                installer = installer.display(),
                parameters = parameter_option,
                destination = destination_option,
            );

            trace!("install helper script content:");
            writeln!(script, "ECHO OFF")?;
            trace!("{}", &install_command);
            writeln!(script, "{}", install_command)?;
        }

        info!("install {}", installer.display());
        info!("to {}", destination.display());
        let installer_script = install_helper.into_temp_path();
        self.install_from_temp_command(&installer_script)?;
        installer_script.close()?;
        Ok(())
    }

    fn installer(&self) -> &Path {
        self.installer()
    }

    fn after_install(&self) -> InstallerResult<()> {
        if let Some((from, to)) = &self.rename() {
            uvm_move_dir::move_dir(from, to)?;
        }
        Ok(())
    }
    fn before_install(&self) -> InstallerResult<()> {
        if self.destination().exists() {
            if self.destination().is_dir() {
                info!(
                    "Destination directory {} already exists, removing it",
                    self.destination().display()
                );
                fs::remove_dir_all(self.destination())
                    .context("failed to remove the existing destination directory")?;
            } else {
                info!(
                    "Destination file {} already exists, removing it",
                    self.destination().display()
                );
                fs::remove_file(self.destination())
                    .context("failed to remove the existing destination file")?;
            }
        }
        Ok(())
    }
}

impl InstallHandler for ModuleExeInstaller {
    fn install_handler(&self) -> InstallerResult<()> {
        let installer = self.installer();

        debug!("install api from installer exe");
        let mut install_helper = Builder::new().suffix(".cmd").rand_bytes(20).tempfile()?;

        info!(
            "create install helper script {}",
            install_helper.path().display()
        );

        {
            let script = install_helper.as_file_mut();
            let parameter_option = match self.cmd() {
                Some(parameters) => parameters,
                _ => "/S",
            };

            let install_command = format!(
                r#"CALL "{installer}" {parameters}"#,
                installer = installer.display(),
                parameters = parameter_option,
            );

            trace!("install helper script content:");
            writeln!(script, "ECHO OFF")?;
            trace!("{}", &install_command);
            writeln!(script, "{}", install_command)?;
        }

        info!("install {}", installer.display());
        let installer_script = install_helper.into_temp_path();
        self.install_from_temp_command(&installer_script)?;
        installer_script.close()?;
        Ok(())
    }

    fn after_install(&self) -> InstallerResult<()> {
        if let Some((from, to)) = &self.rename() {
            uvm_move_dir::move_dir(from, to)?;
        }
        Ok(())
    }

    fn installer(&self) -> &Path {
        self.installer()
    }
}