Add support for routines; state messages

app/classes/logical/packages/APTManager.js

@@ -8,7 +8,7 @@ class APTManager extends PackageManager {
     _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_add_repo = `add-apt-repository '%%URI%%'`
     _command_preflight = 'apt-get update'
 
     _status_keymap = {

app/classes/routine/Routine.js

@@ -0,0 +1,62 @@
+const { Injectable } = require('flitter-di')
+const RoutineExecutionResult = require('./RoutineExecutionResult')
+const StepResult = require('./StepResult')
+const InvalidRoutineTypeError = require('./error/InvalidRoutineTypeError')
+
+class Routine extends Injectable {
+    static get services() {
+        return [...super.services, 'states', 'app']
+    }
+
+    _config
+    _hosts
+    _type
+
+    constructor(hosts, config, type = 'checks') {
+        super()
+        this.app.make(StepResult)
+        this.app.make(RoutineExecutionResult)
+
+        this._config = config
+        this._hosts = hosts
+        this._type = type
+    }
+
+    async execute() {
+        const result = await this._build_result()
+
+        for ( const step of result.steps ) {
+            if ( this._type === 'checks' ) {
+                step.status = (await step.step.check()) ? 'success' : 'fail'
+                step.message = step.status === 'success' ? 'Check passed.' : step.step.check_message()
+            } else if ( this._type === 'apply' ) {
+                if ( !(await step.step.check()) ) {
+                    await step.step.apply()
+                    step.status = (await step.step.check()) ? 'success' : 'fail'
+                    step.message = step.status === 'success' ? 'State applied successfully.' : step.step.failure_message()
+                } else {
+                    step.status = 'success'
+                    step.message = 'Check passed.'
+                }
+            } else {
+                throw new InvalidRoutineTypeError(this._type)
+            }
+        }
+
+        result.overall_state = result.steps.every(x => x.status === 'success') ? 'success' : 'fail'
+        return result
+    }
+
+    async _build_result() {
+        const steps = []
+        for ( const step_config of this._config.steps ) {
+            const step = this.states.from_config(this._hosts[step_config.host], step_config)
+            const result = new StepResult(this, step)
+            steps.push(result)
+        }
+
+        return new RoutineExecutionResult(steps)
+    }
+}
+
+module.exports = exports = Routine

app/classes/routine/RoutineExecutionResult.js

@@ -0,0 +1,23 @@
+const { Injectable } = require('flitter-di')
+
+class RoutineExecutionResult extends Injectable {
+    steps = []
+    overall_state = 'pending' // pending | success | fail
+
+    constructor(steps = []) {
+        super()
+        this.steps = steps
+    }
+
+    get status() {
+        if ( this.steps.some(x => x.status === 'pending') ) return 'pending'
+        else if ( this.steps.some(x => x.status === 'fail') ) return 'fail'
+        else return 'success'
+    }
+
+    failures() {
+        return this.steps.filter(x => x.status === 'fail')
+    }
+}
+
+module.exports = exports = RoutineExecutionResult

app/classes/routine/StepResult.js

@@ -0,0 +1,16 @@
+const { Injectable } = require('flitter-di')
+
+class StepResult extends Injectable {
+    step
+    routine
+    status = 'pending' // pending | success | fail
+    message = ''
+
+    constructor(routine, step) {
+        super()
+        this.routine = routine
+        this.step = step
+    }
+}
+
+module.exports = exports = StepResult

app/classes/routine/error/InvalidRoutineTypeError.js

@@ -0,0 +1,7 @@
+class InvalidRoutineTypeError extends Error {
+    constructor(routine_type) {
+        super(`Invalid routine type: ${routine_type}`)
+    }
+}
+
+module.exports = exports = InvalidRoutineTypeError

app/classes/state/State.js

@@ -19,6 +19,14 @@ class State extends Injectable {
     async reverse() {
         throw new ImplementationError()
     }
+
+    failure_message() {
+        throw new ImplementationError()
+    }
+
+    check_message() {
+        throw new ImplementationError()
+    }
 }
 
 module.exports = exports = State

app/classes/state/fs/DirectoryState.js

@@ -26,6 +26,14 @@ class DirectoryState extends State {
     async _path() {
         return this._host.get_path(this._config.path)
     }
+
+    failure_message() {
+        return `The path "${this._config.path}" does not exist on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = DirectoryState

app/classes/state/fs/DownloadState.js

@@ -46,6 +46,14 @@ class DownloadState extends State {
         if ( !this._config.path ) throw new Error('Missing path config for DownloadState.')
         return this._host.get_path(this._config.path)
     }
+
+    failure_message() {
+        return `The downloaded file "${this._config.path}" does not exist on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = DownloadState

app/classes/state/fs/FileState.js

@@ -31,6 +31,14 @@ class FileState extends State {
         if ( !this._config.path ) throw new Error('Missing path config for FileState.')
         return this._host.get_path(this._config.path)
     }
+
+    failure_message() {
+        return `The file "${this._config.path}" does not exist on the host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = FileState

app/classes/state/fs/OwnerState.js

@@ -39,6 +39,13 @@ class OwnerState extends State {
         return path
     }
 
+    failure_message() {
+        return `The ownership state of the file "${this._config.path}" on host "${this._host.name}" is invalid.`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = OwnerState

app/classes/state/fs/PackState.js

@@ -55,6 +55,14 @@ class PackState extends State {
         if ( !path.is_valid() ) throw new Error(`Invalid path for PathState: ${path}`)
         return path
     }
+
+    failure_message() {
+        return `The archive "${this._config.destination}" does not exist on the host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = PackState

app/classes/state/fs/PermissionState.js

@@ -34,6 +34,14 @@ class PermissionState extends State {
         if ( !path.is_valid() ) throw new Error(`Invalid path for PermissionState: ${path}`)
         return path
     }
+
+    failure_message() {
+        return `The resource permissions for "${this._config.path}" on host "${this._host.name}" are invalid.`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = PermissionState

app/classes/state/fs/UnpackState.js

@@ -58,6 +58,14 @@ class UnpackState extends State {
         if ( !path.is_directory() ) throw new Error(`Invalid extraction path. Must be a directory: ${path}`)
         return path
     }
+
+    failure_message() {
+        return `The unpacked archive does not exist at the path "${this._config.destination}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = UnpackState

app/classes/state/git/CheckoutState.js

@@ -33,6 +33,13 @@ class CheckoutState extends AbstractGitState {
         }
     }
 
+    failure_message() {
+        return `The Git repo at "${this._config.path}" on host "${this._host.name}" is not checked out to the correct ref (${this._config.target}).`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = CheckoutState

app/classes/state/git/CloneState.js

@@ -21,6 +21,13 @@ class CloneState extends AbstractGitState {
         }
     }
 
+    failure_message() {
+        return `Could not find the cloned Git repo at "${this._config.path}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = CloneState

app/classes/state/git/TagState.js

@@ -26,6 +26,13 @@ class TagState extends AbstractGitState {
         }
     }
 
+    failure_message() {
+        return `The tag "${this._config.tag}" does not exist in the Git repo "${this._config.path}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = TagState

app/classes/state/os/CommandState.js

@@ -23,6 +23,13 @@ class CommandState extends State {
         }
     }
 
+    failure_message() {
+        return `Failed to execute the command "${this._config.cmd}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `The command check was not successful.`
+    }
 }
 
 module.exports = exports = CommandState

app/classes/state/os/IsAliveState.js

@@ -0,0 +1,25 @@
+const State = require('../State')
+
+class IsAliveState extends State {
+    async apply() {
+        throw new Error('IsAliveState cannot be applied. It is a check measure only.')
+    }
+
+    async check() {
+        return this._host.is_alive()
+    }
+
+    async reverse() {
+        throw new Error('IsAliveState cannot be reversed. It is a check measure only.')
+    }
+
+    failure_message() {
+        return `Unable to connect to host "${this._host.name}".`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
+}
+
+module.exports = exports = IsAliveState

app/classes/state/os/PackageAbsentState.js

@@ -19,6 +19,14 @@ class PackageAbsentState extends State {
     async apply() {
         return this._host.packages.uninstall(this._config.package)
     }
+
+    failure_message() {
+        return `The package "${this._config.package}" still exists on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = PackageAbsentState

app/classes/state/os/PackageCacheClearedState.js

@@ -23,6 +23,14 @@ class PackageCacheClearedState extends State {
     async reverse() {
         this.output.warn(`Package cache cleared state does not currently support reversal. (Host: ${this._host.name})`)
     }
+
+    failure_message() {
+        return `Failed to clear package cache on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `The package cache on host "${this._host.name}" has not been cleared.`
+    }
 }
 
 module.exports = exports = PackageCacheClearedState

app/classes/state/os/PackageState.js

@@ -19,6 +19,14 @@ class PackageState extends State {
     async reverse() {
         return this._host.packages.uninstall(this._config.package)
     }
+
+    failure_message() {
+        return `The package "${this._config.package}" is not installed on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = PackageState

app/classes/state/os/ServiceDaemonReloadState.js

@@ -23,6 +23,14 @@ class ServiceDaemonReloadState extends State {
     async reverse() {
         this.output.warn(`Service daemon reload state does not currently support reversal. (Host: ${this._host.name})`)
     }
+
+    failure_message() {
+        return `Unable to reload service daemon on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `The service daemon on host "${this._host.name}" has not been reloaded.`
+    }
 }
 
 module.exports = exports = ServiceDaemonReloadState

app/classes/state/os/ServiceRestartState.js

@@ -24,6 +24,14 @@ class ServiceRestartState extends State {
     async reverse() {
         this.output.warn(`Service restart state does not currently support reversal. (Host: ${this._host.name})`)
     }
+
+    failure_message() {
+        return `Unable to restart service "${this._config.service}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `The service "${this._config.service}" on host "${this._host.name}" has not been restarted.`
+    }
 }
 
 module.exports = exports = ServiceRestartState

app/classes/state/os/ServiceState.js

@@ -24,6 +24,15 @@ class ServiceState extends State {
         const services = Array.isArray(this._config.service) ? this._config.service : [this._config.service]
         return this._host.services.stop(...services)
     }
+
+    failure_message() {
+        const services = Array.isArray(this._config.service) ? this._config.service : [this._config.service]
+        return `The service(s) ${services.join(', ')} do not all exist on the host "${this._host.name}."`
+    }
+
+    check_message() {
+        return this.failure_message()
+    }
 }
 
 module.exports = exports = ServiceState

app/classes/state/os/ServiceStoppedState.js

@@ -24,6 +24,14 @@ class ServiceStoppedState extends State {
         const services = Array.isArray(this._config.service) ? this._config.service : [this._config.service]
         return this._host.services.stop(...services)
     }
+
+    failure_message() {
+        return `Unable to stop service "${this._config.service}" on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `The service "${this._config.service}" on host "${this._host.name}" has not been stopped.`
+    }
 }
 
 module.exports = exports = ServiceStoppedState

app/classes/state/os/UpdateState.js

@@ -24,6 +24,14 @@ class UpdateState extends State {
     async reverse() {
         this.output.warn(`Update state does not currently support reversing package updates. (Host: ${this._host.name})`)
     }
+
+    failure_message() {
+        return `Unable to update packages on host "${this._host.name}."`
+    }
+
+    check_message() {
+        return `There are package updates pending on the host "${this._host.name}."`
+    }
 }
 
 module.exports = exports = UpdateState

app/services/routines.service.js

@@ -0,0 +1,30 @@
+const { Service } = require('flitter-di')
+const Routine = require('../classes/routine/Routine')
+
+/*
+ * routines Service
+ * -------------------------------------------------------------
+ * This is a service file that will be made available through Flitter's
+ * dependency injector to the rest of the application based on its given
+ * canonical name.
+ *
+ * e.g. app.di().service("routines")
+ */
+class RoutinesService extends Service {
+    static get services() {
+        return [...super.services, 'app', 'configs', 'hosts']
+    }
+    
+    async get(name) {
+        this.app.make(Routine)
+        const config = this.configs.get(`routines:${name}`)
+        const hosts = {}
+        for ( const host_name of config.hosts ) {
+            hosts[host_name] = await this.hosts.get(host_name)
+        }
+
+        return new Routine(hosts, config, config.type)
+    }
+}
+
+module.exports = exports = RoutinesService

app/services/states.service.js

@@ -27,6 +27,7 @@ class StatesService extends Service {
         'git.tag': require('../classes/state/git/TagState'),
 
         'os.cmd': require('../classes/state/os/CommandState'),
+        'os.alive': require('../classes/state/os/IsAliveState'),
 
         'package.present': require('../classes/state/os/PackageState'),
         'package.absent': require('../classes/state/os/PackageAbsentState'),
@@ -45,13 +46,18 @@ class StatesService extends Service {
         return [...super.services, 'app', 'configs']
     }
 
+    map() {
+        return this.constructor.#state_map
+    }
+
     from_config(host, state_config) {
         const type = state_config.type
+        state_config = {...state_config}
         delete state_config.type
 
         const StepClass = this.constructor.#state_map[type]
-        this.app.di().make(StepClass)
         if ( !StepClass ) throw new Error(`Invalid or unknown step type: ${type}`)
+        this.app.make(StepClass)
 
         return new StepClass(host, state_config)
     }