Disabled cgo since this avoids glibc version errors

Makefile

@@ -1,4 +1,4 @@
-VERSION=0.1.0
+VERSION=0.1.2
 
 BUILDDIR = .
 _BUILDDIR = $(shell realpath $(BUILDDIR))/
@@ -6,7 +6,7 @@ _BUILDDIR = $(shell realpath $(BUILDDIR))/
 build: build-server build-container build-extra
 
 build-server:
-	cd server/ && go build -o $(_BUILDDIR)/docker4ssh
+	cd server/ && CGO_ENABLED=0 go build -o $(_BUILDDIR)/docker4ssh
 
 build-container: DEBUG=false
 build-container:
@@ -17,15 +17,15 @@ build-container:
 	fi
 	cp -rf $(_BUILDDIR)/x86_64-unknown-linux-musl/$(shell if $(DEBUG); then echo debug; else echo release; fi)/configure $(_BUILDDIR)
 
-build-extra: SSHPASS:=$(shell LC_ALL=C tr -dc 'A-Za-z0-9!#$%&()*,-./:<=>?@[\]^_{}~' < /dev/urandom | head -c 18 ; echo)
+build-extra: SSHPASS:=$(shell LC_ALL=C tr -dc 'A-Za-z0-9!#$%&()*,-.:<=>?@[]^_{}~' < /dev/urandom | head -c 18 ; echo)
 build-extra:
-	if [ "$(_BUILDDIR)" != "$(shell realpath .)/" ]; then\
+	@if [ "$(_BUILDDIR)" != "$(shell realpath .)/" ]; then\
 		cp -rf LICENSE $(_BUILDDIR)/LICENSE;\
 		cp -rf man/ $(_BUILDDIR);\
 	fi
 	yes | ssh-keygen -t ed25519 -f $(_BUILDDIR)/docker4ssh.key -N "$(SSHPASS)" -b 4096 > /dev/null
 	cp -rf extra/docker4ssh.conf $(_BUILDDIR)
-	sed -i 's|Passphrase = ""|Passphrase = "$(SSHPASS)"|' $(_BUILDDIR)/docker4ssh.conf
+	sed -i "s|Passphrase = \"\"|Passphrase = \"$(SSHPASS)\"|" $(_BUILDDIR)/docker4ssh.conf
 	cat extra/database.sql | sqlite3 $(_BUILDDIR)/docker4ssh.sqlite3
 	mkdir -p $(_BUILDDIR)/profile/ && cp -f extra/profile.conf $(_BUILDDIR)/profile/
 
@@ -67,6 +67,8 @@ install:
 	install -Dm644 $(_BUILDDIR)profile/* -t $(DESTDIR)/etc/docker4ssh/profile/
 	install -Dm644 $(_BUILDDIR)LICENSE $(DESTDIR)/etc/docker4ssh/LICENSE
 
+	touch $(DESTDIR)/etc/docker4ssh/docker4ssh.log && chmod 777 $(DESTDIR)/etc/docker4ssh/docker4ssh.log
+
 uninstall:
 	rm -rf $(DESTDIR)/etc/docker4ssh/
 	rm -f $(DESTDIR)$(PREFIX)/bin/docker4ssh

README.md

@@ -47,17 +47,11 @@
 
 For every install method your OS **must** be linux and docker has to be installed.
 
-- Download from the latest release (currently only x64 architecture supported)
+- From the latest release (currently only x64 architecture supported)
-  - Download `docker4ssh-<version>.tar.gz` from the [latest release](https://github.com/ByteDream/docker4ssh/releases/latest)
+
-  - Install it
+  Replace the `RELEASE` value in the following oneliner with the latest release [version](https://github.com/ByteDream/docker4ssh/releases/latest).
-    - Into your root directory (recommended)
+  ```shell
-    ```shell
+  $ export RELEASE=<latest version> && curl -L https://github.com/ByteDream/docker4ssh/releases/download/v$RELEASE/docker4ssh-$RELEASE.tar.gz | tar -xvzf - -C /
-    $ sudo tar -xvzf docker4ssh-<version>.tar.gz -C /
-    ```
-    - To the same directory
-    ```shell
-    $ sudo tar -xvzf docker4ssh-<version>.tar.gz
-    ```
 - Building from source
 
     Before start installing, make sure you have to following things ready:
@@ -69,6 +63,7 @@ For every install method your OS **must** be linux and docker has to be installe
     ```shell
     $ git clone https://github.com/ByteDream/docker4ssh
     $ cd docker4ssh
+    $ make build
     $ make install
     ```
 

container/src/configure/cli/cli.rs

@@ -1,7 +1,4 @@
-use std::fmt::{Debug, format};
+use std::process::Command;
-use std::net::TcpStream;
-use std::os::unix::process::ExitStatusExt;
-use std::process::{Command, ExitStatus};
 use std::time::SystemTime;
 use log::{info, warn};
 use structopt::StructOpt;
@@ -9,7 +6,7 @@ use structopt::clap::AppSettings;
 use crate::configure::cli::parser;
 use crate::shared::api::api::API;
 use crate::shared::api::request;
-use crate::shared::api::request::{ConfigGetResponse, ConfigNetworkMode, ConfigPostRequest, ConfigRunLevel};
+use crate::shared::api::request::{ConfigGetResponse, ConfigNetworkMode, ConfigRunLevel};
 
 type Result<T> = std::result::Result<T, failure::Error>;
 
@@ -24,9 +21,6 @@ trait Execute {
     settings = &[AppSettings::ArgRequiredElseHelp]
 )]
 struct Opts {
-    #[structopt(short, long, global = true, help = "Verbose output")]
-    verbose: bool,
-
     #[structopt(subcommand)]
     commands: Option<Root>
 }
@@ -259,7 +253,7 @@ enum Root {
 pub fn cli(route: String) {
     if let Some(subcommand) = Opts::from_args().commands {
         let mut result: Result<()> = Ok(());
-        let mut api = API::new(route, String::new());
+        let mut api = API::new(route);
         match subcommand {
             Root::Auth(auth) => {
                 if let Some(subsubcommand) = auth.commands {

container/src/configure/cli/parser.rs

@@ -1,5 +1,3 @@
-use std::f32::consts::E;
-use std::fmt::format;
 use crate::shared::api::request::{ConfigNetworkMode, ConfigRunLevel};
 
 pub fn parse_network_mode(src: &str) -> Result<ConfigNetworkMode, String> {

container/src/configure/main.rs

@@ -1,13 +1,13 @@
 use std::fs;
-use std::net::TcpStream;
-use std::os::unix::net::UnixStream;
 use std::process::exit;
-use log::{LevelFilter, trace, warn, info, error};
+use log::{LevelFilter, error};
 use docker4ssh::configure::cli;
 use docker4ssh::shared::logging::init_logger;
 
 fn main() {
-    init_logger(LevelFilter::Debug);
+    if init_logger(LevelFilter::Debug).is_err() {
+        println!("Failed to initialize logger");
+    }
 
     match fs::read_to_string("/etc/docker4ssh") {
         Ok(route) => cli(route),

container/src/shared/api/api.rs

@@ -1,21 +1,18 @@
 use std::collections::HashMap;
 use std::io::{Read, Write};
 use std::net::TcpStream;
-use log::Level::Error;
 use serde::Deserialize;
 
 pub type Result<T> = std::result::Result<T, failure::Error>;
 
 pub struct API {
     route: String,
-    host: String,
 }
 
 impl API {
-    pub const fn new(route: String, host: String) -> Self {
+    pub const fn new(route: String) -> Self {
         API {
             route,
-            host,
         }
     }
 
@@ -86,7 +83,7 @@ impl APIResult {
         let result: T = serde_json::from_str(&self.result_body).map_err(|e| {
             // checks if the error has a body and if so, return it
             if self.has_body() {
-                let error: APIError = serde_json::from_str(&self.result_body).unwrap_or_else(|ee| {
+                let error: APIError = serde_json::from_str(&self.result_body).unwrap_or_else(|_| {
                     APIError{message: format!("could not deserialize response: {}", e.to_string())}
                 });
                 failure::format_err!("Failed to call '{}': {}", self.request_path, error.message)

container/src/shared/api/request.rs

@@ -1,6 +1,5 @@
 use std::fmt::{Display, Formatter};
 use serde::{Deserialize, Serialize};
-use serde::de::Unexpected::Str;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::shared::api::api::{API, Method, Request, Result};

container/src/shared/logging/logger.rs

@@ -1,9 +1,9 @@
-use log::{info, Metadata, Record};
+use log::{Metadata, Record};
 
 pub struct Logger;
 
 impl log::Log for Logger {
-    fn enabled(&self, metadata: &Metadata) -> bool {
+    fn enabled(&self, _metadata: &Metadata) -> bool {
         true
     }
 
@@ -13,7 +13,5 @@ impl log::Log for Logger {
         }
     }
 
-    fn flush(&self) {
+    fn flush(&self) {}
-        todo!()
-    }
 }

container/src/shared/logging/mod.rs

@@ -4,8 +4,6 @@ pub mod logger;
 
 pub use logger::Logger;
 
-static LOGGER: Logger = Logger;
-
 pub fn init_logger(level: LevelFilter) -> Result<(), SetLoggerError> {
     log::set_logger(&Logger).map(|()| log::set_max_level(level))
 }