Initial Commit

app/classes/logical/ExecutionResult.js

@@ -0,0 +1,29 @@
+const { Injectable } = require('flitter-di')
+
+class ExecutionResult extends Injectable {
+    stdout = []
+    stderr = []
+    exit_code = 0
+
+    out(data) {
+        this.stdout = this.stdout.concat(String(data).split('\n'))
+    }
+
+    error(data) {
+        this.stderr = this.stderr.concat(String(data).split('\n'))
+    }
+
+    exit(code) {
+        this.exit_code = Number(code)
+    }
+
+    get clean_out() {
+        return this.stdout.filter(Boolean)
+    }
+
+    get clean_err() {
+        return this.stdout.filter(Boolean)
+    }
+}
+
+module.exports = exports = ExecutionResult

app/classes/logical/SystemMetrics.js

@@ -0,0 +1,24 @@
+const { Injectable } = require('flitter-di')
+
+class SystemMetrics extends Injectable {
+    _cpu = 0
+    _ram = 0
+    _mounts = {}
+
+    cpu(set = false) {
+        if ( set !== false ) this._cpu = set
+        else return this._cpu
+    }
+
+    ram(set = false) {
+        if ( set !== false ) this._ram = set
+        else return this._ram
+    }
+
+    mount(point, set = false) {
+        if ( set !== false ) this._mounts[point] = set
+        else return this._mounts[point]
+    }
+}
+
+module.exports = exports = SystemMetrics

app/classes/logical/UniversalPath.js

@@ -0,0 +1,167 @@
+const { Injectable } = require('flitter-di')
+const moment = require('moment')
+
+class UniversalPath extends Injectable {
+    static get services() {
+        return [...super.services, 'hosts']
+    }
+
+    static PATH_TYPE_FILE = Symbol('file')
+    static PATH_TYPE_DIRECTORY = Symbol('directory')
+    static PATH_TYPE_UNKNOWN = Symbol('unknown')
+    _directory_classify_command = 'test -d'
+    _file_classify_command = 'test -f'
+    _datetime_format = 'Y-MM-DD_HH-mm-ss-SSSS'
+
+    static fromString(path_string) {
+        const parts = path_string.split('::')
+        const hostname = parts.length > 1 ? parts[0] : 'localhost'
+        const path = parts.length > 1 ? parts[1] : parts[0]
+        const host = this.prototype.hosts.get(hostname)
+        return new this(host, path)
+    }
+
+    constructor(host, host_path, type) {
+        super()
+        this._host = host
+        this._path = host_path
+        this._type = type ? type : this.constructor.PATH_TYPE_UNKNOWN
+    }
+
+    get host() {
+        return this._host
+    }
+
+    get path() {
+        return this._path
+    }
+
+    get type() {
+        return this._type
+    }
+
+    async resolve() {
+        return this._host.resolve_path(this._path)
+    }
+
+    is_directory() {
+        return this.type === this.constructor.PATH_TYPE_DIRECTORY
+    }
+
+    is_file() {
+        return this.type === this.constructor.PATH_TYPE_FILE
+    }
+
+    is_valid() {
+        return this.is_file() || this.is_directory()
+    }
+
+    async classify() {
+        const dir_result = await this._host.execute(`${this._directory_classify_command} ${this._path}`)
+        if ( dir_result.exit_code === 0 ) {
+            this._type = this.constructor.PATH_TYPE_DIRECTORY
+            return
+        }
+
+        const file_result = await this._host.execute(`${this._file_classify_command} ${this._path}`)
+        if ( file_result.exit_code === 0 ) {
+            this._type = this.constructor.PATH_TYPE_FILE
+            return
+        }
+
+        this._type = this.constructor.PATH_TYPE_UNKNOWN
+    }
+
+    async open_read_stream() {
+        await this.classify()
+        if ( this._type === this.constructor.PATH_TYPE_FILE ) {
+            return this._host.open_file_read_stream(this._path)
+        } else {
+            throw new Error('Maestro does not support generation of read streams for this type of path: '+this._type.description)
+        }
+    }
+
+    async open_write_stream() {
+        await this.classify()
+        if (
+            [this.constructor.PATH_TYPE_FILE, this.constructor.PATH_TYPE_UNKNOWN].includes(this._type)
+        ) {
+            return this._host.open_file_write_stream(this._path)
+        } else {
+            throw new Error('Maestro does not support generation of write streams for this type of path: '+this._type.description)
+        }
+    }
+
+    async copy_from(other_path) {
+        const read = await other_path.open_read_stream()
+        const write = await this.open_write_stream()
+        await read.pipe(write)
+    }
+
+    async copy_to(other_path) {
+        const read = await this.open_read_stream()
+        const write = await other_path.open_write_stream()
+        await read.pipe(write)
+    }
+
+    async unlink() {
+        await this.host.delete_path(this._path)
+    }
+
+    async move_from(other_path) {
+        await this.copy_from(other_path)
+        await other_path.unlink()
+    }
+
+    async move_to(other_path) {
+        await this.copy_to(other_path)
+        await this.unlink()
+    }
+
+    async touch(directory = false) {
+        await this.classify()
+        if ( !directory ) {
+            const base_dir = this._path.split('/').slice(0, -1).join('/')
+            await this._host.run(`mkdir -p ${base_dir}`)
+            await this._host.run(`touch ${this._path}`)
+        } else {
+            await this._host.run(`mkdir -p ${this._path}`)
+        }
+    }
+
+    async echo(text) {
+        await this.classify()
+        if ( this.is_directory() ) {
+            throw new Error('Cannot echo to a directory.')
+        }
+
+        if ( !this.is_valid() ) {
+            await this.touch()
+        }
+
+        const ws = await this.open_write_stream()
+        ws.write(text)
+        return new Promise(resolve => {
+            ws.on('finish', () => resolve())
+            ws.end()
+        })
+    }
+
+    async hash() {
+        const line = await this._host.run_line_result(`sha256sum ${this._path}`)
+        return line.split(' ')[0]
+    }
+
+    async backup() {
+        const now = moment().format(this._datetime_format)
+        const backup_path = `${this}.maestro-backup-${now}`
+        const backup_target = this.constructor.fromString(backup_path)
+        await this.copy_to(backup_target)
+    }
+
+    toString() {
+        return `${this._host.name}::${this._path}`
+    }
+}
+
+module.exports = exports = UniversalPath

app/classes/logical/packages/APTManager.js

@@ -0,0 +1,177 @@
+const PackageManager = require('./PackageManager')
+
+class APTManager extends PackageManager {
+    _command_install_package = 'apt-get install -y %%PACKAGE%%'
+    _command_uninstall_package = 'apt-get purge -y %%PACKAGE%%'
+    _command_update_package = 'apt-get upgrade -y %%PACKAGE%%'
+    _command_reinstall_package = 'apt-get install -y --reinstall %%PACKAGE%%'
+    _command_clear_cache = 'apt-get clean'
+    _command_count_installed = 'dpkg --list | wc -l'
+    _command_count_available = 'apt-cache pkgnames | wc -l'
+    _command_add_repo = `add-apt-repository '%%URI%%`
+    _command_preflight = 'apt-get update'
+
+    _status_keymap = {
+        package: 'name',
+        filename: 'source',
+        section: 'repository',
+        'description-en': 'summary',
+    }
+
+    async status(pkg) {
+        await this.preflight()
+        const result = await this._host.execute(`apt-cache show ${pkg}`)
+        if ( ![0, 100].includes(result.exit_code) ) {
+            throw new Error('Unable to determine package information: '+result.stderr.join('\n'))
+        }
+
+        if ( result.exit_code === 100 ) {
+            return {
+                name: pkg,
+                state: this.constructor.PACKAGE_STATE_UNKNOWN,
+            }
+        }
+
+        const data = {}
+        let last_data_key = false
+        for ( const line of result.clean_out ) {
+            if ( last_data_key && line.startsWith(' ') ) {
+                data[last_data_key] += line
+            } else {
+                const parts = line.trim().split(':')
+                const key = parts[0].toLowerCase()
+                const value = parts.slice(1).join(':').trim()
+                data[key] = value
+                last_data_key = key
+            }
+        }
+
+        for ( const key in this._status_keymap ) {
+            if ( !this._status_keymap.hasOwnProperty(key) ) continue
+            if ( data[key] ) {
+                data[this._status_keymap[key]] = data[key]
+                delete data[key]
+            }
+        }
+
+        // check installation state
+        const install_result = await this._host.execute(`dpkg -s ${pkg}`)
+        data.state = install_result.exit_code === 0 ? this.constructor.PACKAGE_STATE_INSTALLED : this.constructor.PACKAGE_STATE_AVAILABLE
+
+        return data
+    }
+
+    async list_updates() {
+        await this.preflight()
+        const result = await this._host.execute(`apt-get --just-print upgrade`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to determine packages for update: '+result.stderr.join('\n'))
+        }
+
+        let start_index = -1
+        let end_index = -1
+        for ( let i in result.clean_out ) {
+            const line = result.clean_out[i]
+            if ( line.toLowerCase().indexOf('packages will be upgraded') > -1 ) {
+                start_index = Number(i)+1
+            } else if ( start_index > -1 && i >= start_index ) {
+                if ( line.indexOf('newly installed,') > -1 ) break
+                else {
+                    end_index = Number(i)
+                }
+            }
+        }
+
+        const package_strings = result.clean_out.slice(start_index, end_index+1).join(' ').split(' ').filter(Boolean).map(x => x.trim())
+        const updates = result.clean_out.filter(x => x.startsWith('Inst ')).map(x => {
+            x = x.substring(5)
+            x = x.split(' ')
+            const data = {
+                name: x[0],
+                version: x[1].slice(1, -1),
+                repository: x[3].replace(/,/g, ''),
+                architecture: x.reverse()[0].replace(/[\[\])(]/g, '')
+            }
+            return data
+        }).filter(x => package_strings.includes(x.name))
+        return updates
+    }
+
+    async list_repos() {
+        await this.preflight()
+        const result = await this._host.execute(`apt-cache policy`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to read repository list: '+result.stderr.join('\n'))
+        }
+
+        const lines = []
+        for ( const line of result.clean_out ) {
+            if ( line.trim().startsWith('500') ) {
+                lines.push(line)
+            } else if ( line.toLowerCase().startsWith('pinned packages') ) {
+                break
+            }
+        }
+
+        return lines.map(x => x.trim()).filter(x => x.startsWith('500')).map(x => x.split(' ')[2])
+    }
+
+    async list_installed() {
+        const result = await this._host.execute(`dpkg --list`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to determine installed packages: '+result.stderr.join('\n'))
+        }
+
+        let header_line = result.clean_out.filter(x => x.trim().startsWith('+'))[0]
+        let drop_count = 0
+        while ( header_line.startsWith('+') ) {
+            drop_count += 1
+            header_line = header_line.substring(1)
+        }
+
+        let start_at = 0
+        for ( let i in result.clean_out ) {
+            if ( result.clean_out[i].startsWith('+') ) {
+                start_at = Number(i)+1
+                break
+            }
+        }
+
+        return result.clean_out.slice(start_at).map(x => {
+            x = x.substring(drop_count).trim().split(' ').filter(Boolean)
+            return {
+                name: x[0],
+                version: x[1],
+                architecture: x[2],
+                summary: x.slice(3).join(' ')
+            }
+        })
+    }
+
+    async search(pkg) {
+        await this.preflight()
+        const result = await this._host.execute(`apt-cache search ${pkg}`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to search the package cache: '+result.stderr.join('\n'))
+        }
+
+        const results = []
+        for ( const line of result.clean_out ) {
+            const parts = line.trim().split(' - ').map(x => x.trim())
+            results.push({
+                name: parts[0],
+                summary: parts[1]
+            })
+        }
+        return results
+    }
+
+    async preflight() {
+        const result = await this._host.execute(this._command_preflight)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Error encountered during preflight for APTManager: '+result.stderr.join('\n'))
+        }
+    }
+}
+
+module.exports = exports = APTManager

app/classes/logical/packages/DNFManager.js

@@ -0,0 +1,128 @@
+const PackageManager = require('./PackageManager')
+
+class DNFManager extends PackageManager {
+    _command_install_package = 'dnf install -y %%PACKAGE%%'
+    _command_uninstall_package = 'dnf remove -y %%PACKAGE%%'
+    _command_update_package = 'dnf update -y %%PACKAGE%%'
+    _command_reinstall_package = 'dnf reinstall -y %%PACKAGE%%'
+    _command_add_repo = 'dnf config-manager -y --add-repo="%%URI%%"'
+    _command_clear_cache = 'dnf clean all'
+    _command_count_installed = 'dnf list installed -q | wc -l'
+    _command_count_available = 'dnf list available -q | wc -l'
+
+    async status(pkg) {
+        const result = await this._host.execute(`dnf info -q --installed ${pkg}`)
+        if ( result.exit_code === 0 ) {
+            const data = this._data_from_result(result.clean_out)
+            data.state = this.constructor.PACKAGE_STATE_INSTALLED
+            return data
+        } else {
+            const available_result = await this._host.execute(`dnf info -q --available ${pkg}`)
+            if ( available_result.exit_code === 0 ) {
+                const data = this._data_from_result(available_result.clean_out)
+                data.state = this.constructor.PACKAGE_STATE_AVAILABLE
+                return data
+            } else {
+                return {
+                    name: pkg,
+                    state: this.constructor.PACKAGE_STATE_UNKNOWN,
+                }
+            }
+        }
+    }
+
+    async list_updates() {
+        const result = await this._host.execute(`dnf check-update -q`)
+        // 100 is the known exit code for successful result, but updates pending
+        if ( ![0, 100].includes(result.exit_code) ) {
+            throw new Error('Unable to check for updates: '+result.stderr.join('\n'))
+        }
+
+        const updates = []
+        for ( const line of result.clean_out ) {
+            const parts = line.trim().split(' ').filter(Boolean)
+            const data = this._package_info_from_line_parts(parts)
+            updates.push(data)
+        }
+
+        return updates
+    }
+
+    async list_repos() {
+        const result = await this._host.execute(`dnf repolist all -q`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to determine repositories: '+result.stderr.join('\n'))
+        }
+
+        const offset_length = result.clean_out[0].toLowerCase().indexOf('repo name')
+        return result.clean_out.slice(1).map(line => line.substr(0, offset_length).trim())
+    }
+
+    async list_installed() {
+        const result = await this._host.execute(`dnf list installed -q`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to determine installed packages: '+result.stderr.join('\n'))
+        }
+
+        const results = []
+        for ( const line of result.clean_out.slice(1) ) {
+            const parts = line.trim().split(' ').filter(Boolean)
+            const data = this._package_info_from_line_parts(parts)
+            results.push(data)
+        }
+        return results
+    }
+
+    async search(term) {
+        const result = await this._host.execute(`dnf search ${term} -q`)
+        if ( result.exit_code !== 0 ) {
+            throw new Error('Unable to complete search: '+result.stderr.join('\n'))
+        }
+
+        const results = []
+        for ( const line of result.clean_out ) {
+            if ( !line.trim().startsWith('=') ) {
+                const parts = line.split(':').map(x => x.trim())
+                const data = this._package_info_from_line_parts(parts)
+                if ( data.version ) {
+                    data.summary = data.version
+                    delete data.version
+                }
+                results.push(data)
+            }
+        }
+
+        return results
+    }
+
+    _data_from_result(stdout) {
+        const data = {}
+        for ( const line of stdout ) {
+            const parts = line.split(':').map(x => String(x).trim())
+            if ( parts.length > 1 && parts[0] ) {
+                let key = parts[0].toLowerCase()
+                if ( key === 'from repo' ) key = 'repo'
+                data[key] = parts.slice(1).join(':')
+            }
+        }
+
+        return data
+    }
+
+    _package_info_from_line_parts(parts) {
+        const data = {}
+        if ( parts.length > 0 ) {
+            data.name = parts[0]
+            if ( data.name.indexOf('.') >= 0 ) {
+                const arch_parts = data.name.split('.').reverse()
+                data.architecture = arch_parts[0]
+                data.name = arch_parts.slice(1).reverse().join('.')
+            }
+        }
+        if ( parts.length > 1 ) data.version = parts[1]
+        if ( parts.length > 2 ) data.repository = parts[2]
+        return data
+    }
+}
+
+module.exports = exports = DNFManager

app/classes/logical/packages/PackageManager.js

@@ -0,0 +1,104 @@
+const { Injectable } = require('flitter-di')
+const ImplementationError = require('libflitter/errors/ImplementationError')
+
+class PackageManager extends Injectable {
+    static get services() {
+        return [...super.services, 'hosts']
+    }
+
+    static PACKAGE_STATE_INSTALLED = 'installed'
+    static PACKAGE_STATE_AVAILABLE = 'available'
+    static PACKAGE_STATE_UNKNOWN = 'unknown'
+
+    _command_install_package = '%%PACKAGE%%'
+    _command_uninstall_package = '%%PACKAGE%%'
+    _command_update_package = '%%PACKAGE%%'
+    _command_reinstall_package = '%%PACKAGE%%'
+    _command_add_repo = '%%URI%%'
+    _command_clear_cache = ''
+    _command_count_installed = ''
+    _command_count_available = ''
+
+    _group_packages_by = ' '
+
+    constructor(host_or_hostname) {
+        super()
+        if ( typeof host_or_hostname === 'string' ) {
+            host_or_hostname = this.hosts.get(host_or_hostname)
+        }
+
+        this._host = host_or_hostname
+    }
+
+    async list_updates() {
+        throw new ImplementationError()
+    }
+
+    async list_repos() {
+        throw new ImplementationError()
+    }
+
+    async status(pkg) {
+        throw new ImplementationError()
+    }
+
+    async search(term) {
+        throw new ImplementationError()
+    }
+
+    async list_installed() {
+        throw new ImplementationError()
+    }
+
+    async is_installed(pkg) {
+        const result = await this.status(pkg)
+        return result.state === this.constructor.PACKAGE_STATE_INSTALLED
+    }
+
+    async clear_cache() {
+        await this._host.run_line_result(this._command_clear_cache)
+    }
+
+    async count_installed() {
+        return this._host.run_line_result(this._command_count_installed)
+    }
+
+    async count_available() {
+        return this._host.run_line_result(this._command_count_available)
+    }
+
+    async install(...packages) {
+        await this._standard_format_execution(packages, this._command_install_package)
+    }
+
+    async uninstall(...packages) {
+        await this._standard_format_execution(packages, this._command_uninstall_package)
+    }
+
+    async update(...packages) {
+        await this._standard_format_execution(packages, this._command_update_package)
+    }
+
+    async reinstall(...packages) {
+        await this._standard_format_execution(packages, this._command_reinstall_package)
+    }
+
+    async add_repo(uri) {
+        await this._standard_format_execution([uri], this._command_add_repo, '%%URI%%')
+    }
+
+    async _standard_format_execution(packages, command, placeholder = '%%PACKAGE%%') {
+        if ( this._group_packages_by ) {
+            packages = [packages.join(this._group_packages_by)]
+        }
+
+        for ( const package_name of packages ) {
+            const result = await this._host.execute(command.replace(placeholder, package_name))
+            if ( result.exit_code !== 0 ) {
+                throw new Error(`Error encountered while executing command (${command.replace(placeholder, package_name)}): ${result.stderr.join('\n')}`)
+            }
+        }
+    }
+}
+
+module.exports = exports = PackageManager

app/classes/logical/services/ServiceConfig.js

@@ -0,0 +1,111 @@
+const { Injectable } = require('flitter-di')
+
+class ServiceConfig extends Injectable {
+    static get services() {
+        return [...super.services, 'utility']
+    }
+
+    _data = {
+        after: ['syslog.target', 'network.target'],
+        type: 'simple',
+        restart: 'always',
+        restart_after: '2s',
+        install_to: 'multi-user.target',
+    }
+
+    name(set) { return this._get_or_set('name', set) }
+
+    description(set) { return this._get_or_set('description', set) }
+
+    after(set) { return this._get_or_set('after', set, true) }
+
+    restart(set) { return this._get_or_set('restart', set) }
+
+    restart_after(set) { return this._get_or_set('restart_after', set) }
+
+    type(set) { return this._get_or_set('type', set) }
+
+    user(set) { return this._get_or_set('user', set) }
+
+    group(set) { return this._get_or_set('group', set) }
+
+    directory(set) { return this._get_or_set('directory', set) }
+
+    execute(set) { return this._get_or_set('execute', set) }
+
+    env(set) { return this._get_or_set('env', set) }
+
+    install_to(set) { return this._get_or_set('install_to', set) }
+
+    _export() {
+        return this.utility.deep_copy(this._data)
+    }
+
+    _build() {
+        this._validate()
+        const lines = []
+        lines.push('[Unit]')
+        if ( this.description() ) lines.push(`Description=${this.description()}`)
+        if ( this.after() ) {
+            for ( const item of this.after() ) {
+                lines.push(`After=${item}`)
+            }
+        }
+        lines.push('\n[Service]')
+        if ( this.restart() ) {
+            lines.push(`Restart=${this.restart()}`)
+
+            if ( this.restart_after() ) {
+                lines.push(`RestartSec=${this.restart_after()}`)
+            }
+        }
+
+        if ( this.user() ) {
+            lines.push(`User=${this.user()}`)
+        }
+
+        if ( this.group() ) {
+            lines.push(`Group=${this.group()}`)
+        }
+
+        if ( this.directory() ) {
+            lines.push(`WorkingDirectory=${this.directory()}`)
+        }
+
+        if ( this.execute() ) {
+            lines.push(`ExecStart=${this.execute()}`)
+        }
+
+        if ( this.env() ) {
+            lines.push(`Environment=${this.env()}`)
+        }
+
+        if ( this.install_to() ) {
+            lines.push('\n[Install]')
+            lines.push(`WantedBy=${this.install_to()}`)
+        }
+
+        return lines.join('\n')
+    }
+
+    _validate() {
+        const required_fields = ['name', 'description', 'after', 'type', 'user', 'group', 'directory', 'execute']
+        for ( const field of required_fields ) {
+            if ( !this[field]() ) throw new Error(`Missing required service config field: ${field}`)
+        }
+    }
+    
+    _get_or_set(field, value, arr = false) {
+        if ( value ) {
+            if ( arr ) {
+                if ( !this._data[field] ) this._data[field] = []
+                this._data[field].push(value)
+            } else this._data[field] = value
+            return this
+        }
+        
+        return this._data[field]
+    }
+}
+
+module.exports = exports = ServiceConfig

app/classes/logical/services/ServiceManager.js

@@ -0,0 +1,79 @@
+const { Injectable } = require('flitter-di')
+const ImplementationError = require('libflitter/errors/ImplementationError')
+const ServiceConfig = require('./ServiceConfig')
+
+class ServiceManager extends Injectable {
+    static SERVICE_STATE_STOPPED = 'stopped'
+    static SERVICE_STATE_ERROR = 'error'
+    static SERVICE_STATE_RUNNING = 'running'
+
+    _command_restart_service = '%%SERVICE%%'
+    _command_start_service = '%%SERVICE%%'
+    _command_stop_service = '%%SERVICE%%'
+    _command_reload_service = '%%SERVICE%%'
+    _command_enable_service = '%%SERVICE%%'
+    _command_disable_service = '%%SERVICE%%'
+    _command_daemon_reload = ''
+
+    _group_services_by = ' '
+
+    constructor(host) {
+        super()
+        this._host = host
+    }
+
+    async status(...services) {
+        throw new ImplementationError()
+    }
+
+    async install(config) {
+        throw new ImplementationError()
+    }
+
+    new_config() {
+        return new ServiceConfig()
+    }
+
+    async start(...services) {
+        await this._standard_format_execution(services, this._command_start_service)
+    }
+
+    async stop(...services) {
+        await this._standard_format_execution(services, this._command_stop_service)
+    }
+
+    async restart(...services) {
+        await this._standard_format_execution(services, this._command_restart_service)
+    }
+
+    async reload(...services) {
+        await this._standard_format_execution(services, this._command_reload_service)
+    }
+
+    async enable(...services) {
+        await this._standard_format_execution(services, this._command_enable_service)
+    }
+
+    async disable(...services) {
+        await this._standard_format_execution(services, this._command_disable_service)
+    }
+
+    async daemon_reload() {
+        await this._host.run_line_result(this._command_daemon_reload)
+    }
+
+    async _standard_format_execution(items, command, replace = '%%SERVICE%%') {
+        if ( this._group_services_by ) {
+            items = [items.join(this._group_services_by)]
+        }
+
+        for ( const item of items ) {
+            const result = await this._host.execute(command.replace(replace, item))
+            if ( result.exit_code !== 0 ) {
+                throw new Error('Error encountered while executing command: '+result.stderr.join('\n'))
+            }
+        }
+    }
+}
+
+module.exports = exports = ServiceManager

app/classes/logical/services/SystemDManager.js

@@ -0,0 +1,55 @@
+const ServiceManager = require('./ServiceManager')
+
+class SystemDManager extends ServiceManager {
+    _command_restart_service = 'systemctl restart %%SERVICE%%'
+    _command_start_service = 'systemctl start %%SERVICE%%'
+    _command_stop_service = 'systemctl stop %%SERVICE%%'
+    _command_reload_service = 'systemctl reload %%SERVICE%%'
+    _command_enable_service = 'systemctl enable %%SERVICE%%'
+    _command_disable_service = 'systemctl disable %%SERVICE%%'
+    _command_daemon_reload = 'systemctl daemon-reload'
+
+    async status(...services) {
+        const statuses = []
+        for ( const service_name of services ) {
+            const result = await this._host.execute(`systemctl status -l --value --no-pager ${service_name}`)
+            if ( result.exit_code !== 0 ) {
+                throw new Error(`Unable to determine service state: ${result.stderr.join('\n')}`)
+            }
+
+            const status = result.clean_out.map(x => x.trim().toLowerCase())
+                                        .filter(x => x.startsWith('active:'))[0]
+                                        .split(':')[1]
+                                        .trim()
+
+
+            statuses.push({
+                name: service_name,
+                status: this._determine_status_from_string(status)
+            })
+        }
+
+        return statuses.length === 1 ? statuses[0] : statuses
+    }
+
+    async install(config) {
+        if ( !config._build || !config.name ) throw new Error('Config must be instance of classes/logical/services/ServiceConfig')
+        const file_contents = config._build()
+        const name = config.name()
+
+        const service_file = await this._host.get_path(`/etc/systemd/system/${name}.service`)
+        await service_file.echo(file_contents)
+    }
+
+    _determine_status_from_string(str) {
+        if ( str.startsWith('active') ) {
+            return this.constructor.SERVICE_STATE_RUNNING
+        } else if ( str.startsWith('fail') ) {
+            return this.constructor.SERVICE_STATE_ERROR
+        } else {
+            return this.constructor.SERVICE_STATE_STOPPED
+        }
+    }
+}
+
+module.exports = exports = SystemDManager