covet 2.0.1

CLI and web frontend for scanning with HP Envy printer / scanners
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

#![forbid(unsafe_code)]

use anyhow::Result;
use clap::Parser;
use std::path::Path;
use tokio::runtime::Runtime;
use tracing::info;

mod cli;
mod jpeg;
mod message;
mod scanner;
mod util;
mod web;

use crate::cli::{Opt, ScanOpt, ScannerOpt};
use crate::message::scan_job::{ColorSpace, Format};
use crate::scanner::{Scanner, ScannerError};

fn main() -> Result<()> {
    tracing_subscriber::fmt::init();
    let opt = Opt::parse();
    match opt {
        Opt::Status(opt) => {
            status(&opt)?;
        }
        Opt::Scan(opt) => {
            scan(&opt)?;
        }
        Opt::Web(opt) => {
            let use_tls = !opt.scanner_opts.no_tls;
            web::run_server(
                &opt.scanner_opts.scanner,
                &opt.listen,
                opt.port,
                use_tls,
                opt.disable_jpeg_fix,
            )?;
        }
        Opt::FixJpegHeight(opt) => {
            fix_jpeg_height(&opt.input, &opt.output)?;
        }
    }
    Ok(())
}

fn fix_jpeg_height(input: &Path, ouput: &Path) -> Result<()> {
    let input_buf = std::fs::read(input)?;
    if let Some(buffer) = jpeg::fix_jpeg_height(input_buf.into())? {
        std::fs::write(ouput, buffer)?;
    }
    Ok(())
}

fn status(opt: &ScannerOpt) -> Result<(), ScannerError> {
    let scanner = Scanner::new(&opt.scanner, !opt.no_tls, false);
    let rt = Runtime::new()?;
    rt.block_on(print_scan_status(&scanner))?;
    Ok(())
}

async fn print_scan_status(scanner: &Scanner) -> Result<(), ScannerError> {
    info!("Status of scanner {}", scanner.host());
    let status = scanner.get_scan_status().await?;
    info!(
        "Scanner: {:?}, Adf: {:?}",
        status.scanner_state(),
        status.adf_state()
    );
    Ok(())
}

impl cli::Format {
    fn to_internal(self) -> Format {
        match self {
            cli::Format::Pdf => Format::Pdf,
            cli::Format::Jpeg => Format::Jpeg,
        }
    }
}

impl cli::ColorSpace {
    fn to_internal(self) -> ColorSpace {
        match self {
            cli::ColorSpace::Gray => ColorSpace::Gray,
            cli::ColorSpace::Color => ColorSpace::Color,
        }
    }
}

fn scan(opt: &ScanOpt) -> Result<(), ScannerError> {
    let scanner = Scanner::new(
        &opt.scanner_opts.scanner,
        !opt.scanner_opts.no_tls,
        opt.disable_jpeg_fix,
    );
    let rt = Runtime::new()?;
    rt.block_on(util::scan_to_file(
        scanner,
        opt.format.to_internal(),
        opt.color.to_internal(),
        opt.source,
        opt.resolution,
        opt.compression_quality,
    ))?;
    Ok(())
}