hop-cli 0.2.61

Interact with Hop in your terminal
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

use std::env::temp_dir;
use std::path::{Path, PathBuf};

use anyhow::{anyhow, Context, Result};
use async_compression::tokio::write::GzipEncoder;
use hyper::Method;
use ignore::WalkBuilder;
use reqwest::multipart::{Form, Part};
use tokio::fs::File;
use tokio::io::AsyncWriteExt;
use tokio_tar::Builder as TarBuilder;

use super::types::{Build, SingleBuild};
use crate::commands::deploy::HOP_BUILD_BASE_URL;
use crate::state::http::HttpClient;
use crate::store::hopfile::VALID_HOP_FILENAMES;

pub async fn builder_post(http: &HttpClient, deployment_id: &str, bytes: Vec<u8>) -> Result<Build> {
    let multipart = Form::new().part(
        "file",
        Part::bytes(bytes)
            .file_name("deployment.tar.gz")
            .mime_str("application/x-gzip")?,
    );

    let builder_uri =
        std::env::var("BUILDER_URL").unwrap_or_else(|_| HOP_BUILD_BASE_URL.to_string());

    let response = http
        .client
        .request(
            Method::POST,
            format!("{builder_uri}/deployments/{deployment_id}/builds",).as_str(),
        )
        .header("content_type", "multipart/form-data".to_string())
        .multipart(multipart)
        .send()
        .await?;

    let build = http
        .handle_response::<SingleBuild>(response)
        .await?
        .ok_or_else(|| anyhow!("Could not create build"))?
        .build;

    Ok(build)
}

// default ignore list for tar files
static DEFAULT_IGNORE_LIST: &[&str] = &[
    ".git",
    ".github",
    ".gitmodules",
    ".DS_Store",
    ".idea",
    ".vscode",
];

// compress stuff
pub async fn compress(id: &str, base_dir: PathBuf) -> Result<String> {
    let base_folder_name = Path::new(&id);
    let archive_path = temp_dir().join(format!("hop_{id}.tar.gz"));

    // tarball gunzip stuff
    let writer = File::create(archive_path.clone()).await?;
    let writer = GzipEncoder::new(writer);
    let mut archive = TarBuilder::new(writer);
    archive.follow_symlinks(true);

    log::info!("Finding files to compress...");

    let mut walker = WalkBuilder::new(base_dir.clone());
    walker.add_ignore(create_global_ignore_file().await?);
    walker.add_custom_ignore_filename(".hopignore");
    walker.hidden(false).follow_links(true);

    let walker = walker.build();

    // add all found files to the tarball
    for entry in walker {
        match entry {
            Ok(entry) => {
                log::debug!("Adding {} to tarball", entry.path().display());

                if VALID_HOP_FILENAMES.contains(&entry.file_name().to_str().unwrap()) {
                    continue;
                }

                let path = entry.path().strip_prefix(&base_dir).unwrap().to_owned();

                archive
                    .append_path_with_name(entry.path(), &(*base_folder_name).join(&path))
                    .await?;
            }
            Err(err) => {
                log::warn!("Error walking: {}", err);
            }
        }
    }

    let mut buff = archive.into_inner().await?;
    buff.shutdown().await?;
    let mut buff = buff.into_inner();
    buff.shutdown().await?;

    Ok(archive_path.to_str().unwrap().into())
}

async fn create_global_ignore_file() -> Result<PathBuf> {
    let path = temp_dir().join(".hopignore");
    let mut file = File::create(path.clone())
        .await
        .context("Could not create global ignore file")?;

    file.write_all(DEFAULT_IGNORE_LIST.join("\n").as_bytes())
        .await?;

    file.shutdown().await?;

    Ok(path)
}