staticrocket 0.3.1

Simple http server for serving static content.
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

use std::{fs, path::Path};

use clap::{ArgMatches, Args, Command};

use qsu::{
  argp::{ArgParser, ArgsProc},
  installer::RegSvc,
  rt::SrvAppRt
};

use crate::err::Error;

/// Create a default Rocket.toml file for use with staticrocket.
#[derive(Debug, Args)]
struct GenConf {
  /// Overwrite Rocket.toml if one already exists.
  #[arg(short, long)]
  force: bool
}

/// Create an argument parser.
///
/// This function is needed (rather than just calling `ArgParser::new()`)
/// because the `make-config` subcommand needs to be added.
pub fn create<'cb>(
  svcname: &str,
  cb: &'cb mut dyn ArgsProc<AppErr = Error>
) -> ArgParser<'cb, Error> {
  // Create the "root" command line parser
  let cli = Command::new("")
    .name(env!("CARGO_PKG_NAME"))
    .about(env!("CARGO_PKG_DESCRIPTION"))
    .version(env!("CARGO_PKG_VERSION"));

  // Create "make-config" subcommand
  let mkc_subcmd = Command::new("make-config");
  let mkc_subcmd = GenConf::augment_args(mkc_subcmd);

  // Add make-config subcommand to "root" command line parser
  let cli = cli.subcommand(mkc_subcmd);

  ArgParser::with_cmd(svcname, cli, cb)
}

pub struct AppArgsProc {}

impl qsu::argp::ArgsProc for AppArgsProc {
  type AppErr = Error;

  /// Process an `register-service` subcommand.
  fn proc_inst(
    &mut self,
    _sub_m: &ArgMatches,
    regsvc: RegSvc
  ) -> Result<RegSvc, Self::AppErr> {
    // Use current working directory as the service's workdir
    let cwd = std::env::current_dir()?.to_str().unwrap().to_string();
    let desc = env!("CARGO_PKG_DESCRIPTION");

    let regsvc = regsvc
      .workdir(cwd)
      .netservice()
      .display_name("Rocket HTTP Server")
      .description(desc);

    // ToDo: Print a warning if Rocket.toml doesn't exist in current directory?
    Ok(regsvc)
  }

  /// Application call-back for subcommands that qsu doesn't handle itself.
  fn proc_other(
    &mut self,
    subcmd: &str,
    sub_m: &ArgMatches
  ) -> Result<(), Self::AppErr> {
    match subcmd {
      "make-config" => {
        const ROCKET_TOML: &str = include_str!("../Rocket.toml");

        let force = sub_m.get_flag("force");

        let fname = Path::new("Rocket.toml");
        if fname.exists() {
          if force {
            fs::remove_file(fname)?;
          } else {
            Err(qsu::Error::io("File 'Rocket.toml' already exists."))?;
          }
        }

        fs::write(fname, ROCKET_TOML)?;

        Ok(())
      }
      _ => {
        todo!();
      }
    }
  }

  fn build_apprt(&mut self) -> Result<SrvAppRt<Error>, Self::AppErr> {
    Ok(crate::app::create())
  }
}

// vim: set ft=rust et sw=2 ts=2 sts=2 cinoptions=2 tw=79 :