mrsk 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 45be50e3f2f3c5c629b1ec46ee23394b1913c758385ee431d44553506f40cc01
-  data.tar.gz: fe11053be553d9af7d090b03b019dd09d1578bed94050b6be5699f99f6711be8
+  metadata.gz: a3cbef66064bc4d1a20707788eefd3827d4054d1278d85a8e2b425c4c5ad643e
+  data.tar.gz: 26e48f594d93f1b1a409a4601cc43c6d62fc35e935c7000c17addd6d5f720ac9
 SHA512:
-  metadata.gz: 6eee63c66d3f6585c2ac142d78ffdf952b141073793a8f8dd8d7b1551fbd5a1a98f12c590e83517f8e52e1ac58b07ebd48b55571ebe66c3c8a2ec677c47ef00d
-  data.tar.gz: f46b8fc945be5c43427f7bf2300cbd95e80e30598fd8294e327f83253b25430937d44c255c8edb1d6b0fce613224acb367972bbeef125e7615293c83c23ddb2c
+  metadata.gz: 3c84c6bada6dc82715349630807685d4f8a6c5dd64995760efd88666bc99a1c1b20230f47b23a7b71f8dfab5f4b2f34317d1fd2a5245b8c8a6b45575fa606002
+  data.tar.gz: 83565d28bcde4d782a829312685c2669512f6111233685309b015ed2b087ac5557456faae0460f472b18c480ef20892ae712a07f1b22de2cb2340a9f187c936b

data/README.md

@@ -14,40 +14,47 @@ servers:
   - 192.168.0.2
 registry:
   username: registry-user-name
-  password: <%= ENV["MRSK_REGISTRY_PASSWORD"] %>
+  password: <%= ENV.fetch("MRSK_REGISTRY_PASSWORD") %>
 ```
 
 Now you're ready to deploy a multi-arch image to the servers:
 
 ```
-mrsk deploy
+MRSK_REGISTRY_PASSWORD=pw mrsk deploy
 ```
 
 This will:
 
-1. Install Docker on any server that might be missing it (using apt-get)
-2. Log into the registry both locally and remotely
-3. Build the image using the standard Dockerfile in the root of the application.
-4. Push the image to the registry.
-5. Pull the image from the registry on the servers.
-6. Ensure Traefik is running and accepting traffic on port 80.
-7. Stop any containers running a previous versions of the app.
-8. Start a new container with the version of the app that matches the current git version hash.
-9. Prune unused images and stopped containers to ensure servers don't fill up.
+1. Connect to the servers over SSH (using root by default, authenticated by your loaded ssh key)
+2. Install Docker on any server that might be missing it (using apt-get)
+3. Log into the registry both locally and remotely
+4. Build the image using the standard Dockerfile in the root of the application.
+5. Push the image to the registry.
+6. Pull the image from the registry on the servers.
+7. Ensure Traefik is running and accepting traffic on port 80.
+8. Stop any containers running a previous versions of the app.
+9. Start a new container with the version of the app that matches the current git version hash.
+10. Prune unused images and stopped containers to ensure servers don't fill up.
 
 Voila! All the servers are now serving the app on port 80. If you're just running a single server, you're ready to go. If you're running multiple servers, you need to put a load balancer in front of them.
 
+## Why not just run Capistrano or Kubernetes?
+
+MRSK basically is Capistrano for Containers, which allow us to use vanilla servers as the hosts. No need to ensure that the servers have just the right version of Ruby or other dependencies you need. That all lives in the Docker image now. You can boot a brand new Ubuntu (or whatever) server, add it to the deploy servers of MRSK, and it'll be auto-provisioned with Docker, and run right away. Docker's layer caching also allows for quicker deployments with less mucking about on the server. And the images built for MRSK can be used for CI or later introspection.
+
+Kubernetes is a beast. Running it yourself on your own hardware is not for the faint of heart. It's a fine option if you want to run on someone else's platform, like Render or Fly, but if you'd like the freedom to move between cloud and your own hardware, or even mix the two, MRSK is much simpler. You can see everything that's going on, it's just basic Docker commands being called.
+
 ## Configuration
 
 ### Using another registry than Docker Hub
 
-The default registry for Docker is Docker Hub. If you'd like to use a different one, just configure the server, like so:
+The default registry is Docker Hub, but you can change it using `registry/server`:
 
 ```yaml
 registry:
   server: registry.digitalocean.com
   username: registry-user-name
-  password: <%= ENV["MRSK_REGISTRY_PASSWORD"] %>
+  password: <%= ENV.fetch("MRSK_REGISTRY_PASSWORD") %>
 ```
 
 ### Using a different SSH user than root
@@ -58,9 +65,9 @@ The default SSH user is root, but you can change it using `ssh_user`:
 ssh_user: app
 ```
 
-### Adding custom env variables
+### Using env variables
 
-You can inject custom env variables into the app containers using `env`:
+You can inject env variables into the app containers using `env`:
 
 ```yaml
 env:
@@ -68,9 +75,38 @@ env:
   REDIS_URL: redis://redis1:6379/1
 ```
 
-### Splitting servers into different roles
+### Using secret env variables
+
+If you have env variables that are secret, you can divide the `env` block into `clear` and `secret`:
+
+```yaml
+env:
+  clear:
+    DATABASE_URL: mysql2://db1/hey_production/
+    REDIS_URL: redis://redis1:6379/1
+  secret:
+    - DATABASE_PASSWORD
+    - REDIS_PASSWORD
+```
+
+The list of secret env variables will be expanded at run time from your local machine. So a reference to a secret `DATABASE_PASSWORD` will look for `ENV["DATABASE_PASSWORD"]` on the machine running MRSK. Just like with build secrets.
+
+If the referenced secret ENVs are missing, the configuration will be halted with a `KeyError` exception.
+
+Note: Marking an ENV as secret currently only redacts its value in the output for MRSK. The ENV is still injected in the clear into the container at runtime.
+
+### Using volumes
+
+You can add custom volumes into the app containers using `volumes`:
+
+```yaml
+volumes:
+  - "/local/path:/container/path"
+```
+
+### Using different roles for servers
 
-If your application uses separate hosts for running jobs or other roles beyond the default web running, you can specify these hosts and their custom entrypoint command like so:
+If your application uses separate hosts for running jobs or other roles beyond the default web running, you can specify these hosts in a dedicated role with a new entrypoint command like so:
 
 ```yaml
 servers:
@@ -84,23 +120,35 @@ servers:
     cmd: bin/jobs
 ```
 
-Traefik will only be installed and run on the servers in the `web` role (and on all servers if no roles are defined).
+Note: Traefik will only by default be installed and run on the servers in the `web` role (and on all servers if no roles are defined). If you need Traefik on hosts in other roles than `web`, add `traefik: true`:
 
-### Adding custom container labels
+```yaml
+servers:
+  web:
+    - 192.168.0.1
+    - 192.168.0.2
+  web2:
+    traefik: true
+    hosts:
+      - 192.168.0.3
+      - 192.168.0.4
+```
 
-You can specialize the default Traefik rules by setting custom labels on the containers that are being started:
+### Using container labels
+
+You can specialize the default Traefik rules by setting labels on the containers that are being started:
 
 ```
 labels:
   traefik.http.routers.hey.rule: '''Host(`app.hey.com`)'''
 ```
 
-(Note: The extra quotes are needed to ensure the rule is passed in correctly!)
+Note: The extra quotes are needed to ensure the rule is passed in correctly!
 
 This allows you to run multiple applications on the same server sharing the same Traefik instance and port.
 See https://doc.traefik.io/traefik/routing/routers/#rule for a full list of available routing rules.
 
-The labels can even be applied on a per-role basis:
+The labels can also be applied on a per-role basis:
 
 ```yaml
 servers:
@@ -113,60 +161,147 @@ servers:
       - 192.168.0.4
     cmd: bin/jobs
     labels:
-      my-custom-label: "50"
+      my-label: "50"
 ```
 
-### Configuring remote builder for native multi-arch
+### Using remote builder for native multi-arch
 
-If you're developing on ARM64 (like Apple Silicon), but you want to deploy on AMD64 (x86 64-bit), you have to use multi-archecture images. By default, MRSK will setup a local buildx configuration that allows for this through QEMU emulation. This can be slow, especially on the first build.
+If you're developing on ARM64 (like Apple Silicon), but you want to deploy on AMD64 (x86 64-bit), you can use multi-archecture images. By default, MRSK will setup a local buildx configuration that does this through QEMU emulation. But this can be quite slow, especially on the first build.
 
-If you want to speed up this process by using a remote AMD64 host to natively build the AMD64 part of the image, while natively building the ARM64 part locally, you can do so using builder options like follows:
+If you want to speed up this process by using a remote AMD64 host to natively build the AMD64 part of the image, while natively building the ARM64 part locally, you can do so using builder options:
 
 ```yaml
 builder:
   local:
     arch: arm64
-    host: unix:///Users/dhh/.docker/run/docker.sock
+    host: unix:///Users/<%= `whoami`.strip %>/.docker/run/docker.sock
   remote:
     arch: amd64
     host: ssh://root@192.168.0.1
 ```
 
-Note: You must have Docker running on the remote host being used as a builder.
+Note: You must have Docker running on the remote host being used as a builder. This instance should only be shared for builds using the same registry and credentials.
+
+### Using remote builder for single-arch
 
-With that configuration in place, you can setup the local/remote configuration using `mrsk build create`. If you wish to remove the contexts and buildx instances again, you can run `mrsk build remove`. If you had already built using the standard emulation setup, run `mrsk build remove` before doing `mrsk build remote`.
+If you're developing on ARM64 (like Apple Silicon), want to deploy on AMD64 (x86 64-bit), but don't need to run the image locally (or on other ARM64 hosts), you can configure a remote builder that just targets AMD64. This is a bit faster than building with multi-arch, as there's nothing to build locally.
+
+```yaml
+builder:
+  remote:
+    arch: amd64
+    host: ssh://root@192.168.0.1
+```
 
-### Configuring native builder when multi-arch isn't needed
+### Using native builder when multi-arch isn't needed
 
-If you're developing on the same architecture as the one you're deploying on, you can speed up the build a lot by forgoing a multi-arch image. This can be done by configuring the builder like so:
+If you're developing on the same architecture as the one you're deploying on, you can speed up the build by forgoing both multi-arch and remote building:
 
 ```yaml
 builder:
   multiarch: false
 ```
 
+This is also a good option if you're running MRSK from a CI server that shares architecture with the deployment servers.
+
+### Using build secrets for new images
+
+Some images need a secret passed in during build time, like a GITHUB_TOKEN to give access to private gem repositories. This can be done by having the secret in ENV, then referencing it in the builder configuration:
+
+```yaml
+builder:
+  secrets:
+    - GITHUB_TOKEN
+```
+
+This build secret can then be referenced in the Dockerfile:
+
+```
+# Copy Gemfiles
+COPY Gemfile Gemfile.lock ./
+
+# Install dependencies, including private repositories via access token
+RUN --mount=type=secret,id=GITHUB_TOKEN \
+  BUNDLE_GITHUB__COM=x-access-token:$(cat /run/secrets/GITHUB_TOKEN) \
+  bundle install
+```
+
+### Configuring build args for new images
+
+Build arguments that aren't secret can also be configured:
+
+```yaml
+builder:
+  args:
+    RUBY_VERSION: 3.2.0
+```
+
+This build argument can then be used in the Dockerfile:
+
+```
+# Private repositories need an access token during the build
+ARG RUBY_VERSION
+FROM ruby:$RUBY_VERSION-slim as base
+```
+
+### Using without RAILS_MASTER_KEY
+
+If you're using MRSK with older Rails apps that predate RAILS_MASTER_KEY, or with a non-Rails app, you can skip the default usage and reference:
+
+```yaml
+skip_master_key: true
+```
+
+### Using accessories for database, cache, search services
+
+You can manage your accessory services via MRSK as well. The services will build off public images, and will not be automatically updated when you deploy:
+
+```yaml
+accessories:
+  mysql:
+    image: mysql:5.7
+    host: 1.1.1.3
+    port: 3306
+    env:
+      clear:
+        MYSQL_ROOT_HOST: '%'
+      secret:
+        - MYSQL_ROOT_PASSWORD
+    volumes:
+      - /var/lib/mysql:/var/lib/mysql
+  redis:
+    image: redis:latest
+    host: 1.1.1.4
+    port: "36379:6379"
+    volumes:
+      - /var/lib/redis:/data
+```
+
+Now run `mrsk accessory start mysql` to start the MySQL server on 1.1.1.3. See `mrsk accessory` for all the commands possible.
+
 ## Commands
 
-### Remote execution
+### Running remote execution and runners
 
-If you need to execute commands inside the Rails containers, you can use `mrsk app exec`, `mrsk app exec --once`, `mrsk app runner`, and `mrsk app runner --once`. Examples:
+If you need to execute commands inside the Rails containers, you can use `mrsk app exec` and `mrsk app runner`. Examples:
 
 ```bash
 # Runs command on all servers
 mrsk app exec 'ruby -v'
-App Host: xxx.xxx.xxx.xxx
+App Host: 192.168.0.1
 ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux]
 
-App Host: xxx.xxx.xxx.xxx
+App Host: 192.168.0.2
 ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux]
 
-# Runs command on first server
-mrsk app exec --once 'cat .ruby-version'
+# Runs command on primary server
+mrsk app exec --primary 'cat .ruby-version'
+App Host: 192.168.0.1
 3.1.3
 
 # Runs Rails command on all servers
 mrsk app exec 'bin/rails about'
-App Host: xxx.xxx.xxx.xxx
+App Host: 192.168.0.1
 About your application's environment
 Rails version             7.1.0.alpha
 Ruby version              ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux]
@@ -178,7 +313,7 @@ Environment               production
 Database adapter          sqlite3
 Database schema version   20221231233303
 
-App Host: xxx.xxx.xxx.xxx
+App Host: 192.168.0.2
 About your application's environment
 Rails version             7.1.0.alpha
 Ruby version              ruby 3.1.3p185 (2022-11-24 revision 1a6b16756e) [x86_64-linux]
@@ -190,50 +325,50 @@ Environment               production
 Database adapter          sqlite3
 Database schema version   20221231233303
 
-# Runs Rails runner on first server
-mrsk app runner 'puts Rails.application.config.time_zone'
+# Run Rails runner on primary server
+mrsk app runner -p 'puts Rails.application.config.time_zone'
 UTC
 ```
 
-### Running a Rails console on the primary host
+### Running a Rails console
 
 If you need to interact with the production console for the app, you can use `mrsk app console`, which will start a Rails console session on the primary host. You can start the console on a different host using `mrsk app console --host 192.168.0.2`. Be mindful that this is a live wire! Any changes made to the production database will take effect immeditately.
 
-### Inspecting
+### Running details to see state of containers
 
-You can see the state of your servers by running `mrsk details`. It'll show something like this:
+You can see the state of your servers by running `mrsk details`:
 
 ```
-Traefik Host: xxx.xxx.xxx.xxx
+Traefik Host: 192.168.0.1
 CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                               NAMES
 6195b2a28c81   traefik   "/entrypoint.sh --pr…"   30 minutes ago   Up 19 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp   traefik
 
-Traefik Host: 164.92.105.119
+Traefik Host: 192.168.0.2
 CONTAINER ID   IMAGE     COMMAND                  CREATED          STATUS          PORTS                               NAMES
 de14a335d152   traefik   "/entrypoint.sh --pr…"   30 minutes ago   Up 19 minutes   0.0.0.0:80->80/tcp, :::80->80/tcp   traefik
 
-App Host: 164.90.145.60
+App Host: 192.168.0.1
 CONTAINER ID   IMAGE                                                                         COMMAND                  CREATED          STATUS          PORTS      NAMES
 badb1aa51db3   registry.digitalocean.com/user/app:6ef8a6a84c525b123c5245345a8483f86d05a123   "/rails/bin/docker-e…"   13 minutes ago   Up 13 minutes   3000/tcp   chat-6ef8a6a84c525b123c5245345a8483f86d05a123
 
-App Host: 164.92.105.119
+App Host: 192.168.0.2
 CONTAINER ID   IMAGE                                                                         COMMAND                  CREATED          STATUS          PORTS      NAMES
 1d3c91ed1f55   registry.digitalocean.com/user/app:6ef8a6a84c525b123c5245345a8483f86d05a123   "/rails/bin/docker-e…"   13 minutes ago   Up 13 minutes   3000/tcp   chat-6ef8a6a84c525b123c5245345a8483f86d05a123
 ```
 
 You can also see just info for app containers with `mrsk app details` or just for Traefik with `mrsk traefik details`.
 
-### Rollback
+### Running rollback to fix a bad deploy
 
 If you've discovered a bad deploy, you can quickly rollback by reactivating the old, paused container image. You can see what old containers are available for rollback by running `mrsk app containers`. It'll give you a presentation similar to `mrsk app details`, but include all the old containers as well. Showing something like this:
 
 ```
-App Host: 164.92.105.119
+App Host: 192.168.0.1
 CONTAINER ID   IMAGE                                                                         COMMAND                  CREATED          STATUS                      PORTS      NAMES
 1d3c91ed1f51   registry.digitalocean.com/user/app:6ef8a6a84c525b123c5245345a8483f86d05a123   "/rails/bin/docker-e…"   19 minutes ago   Up 19 minutes               3000/tcp   chat-6ef8a6a84c525b123c5245345a8483f86d05a123
 539f26b28369   registry.digitalocean.com/user/app:e5d9d7c2b898289dfbc5f7f1334140d984eedae4   "/rails/bin/docker-e…"   31 minutes ago   Exited (1) 27 minutes ago              chat-e5d9d7c2b898289dfbc5f7f1334140d984eedae4
 
-App Host: 164.90.145.60
+App Host: 192.168.0.2
 CONTAINER ID   IMAGE                                                                         COMMAND                  CREATED          STATUS                      PORTS      NAMES
 badb1aa51db4   registry.digitalocean.com/user/app:6ef8a6a84c525b123c5245345a8483f86d05a123   "/rails/bin/docker-e…"   19 minutes ago   Up 19 minutes               3000/tcp   chat-6ef8a6a84c525b123c5245345a8483f86d05a123
 6f170d1172ae   registry.digitalocean.com/user/app:e5d9d7c2b898289dfbc5f7f1334140d984eedae4   "/rails/bin/docker-e…"   31 minutes ago   Exited (1) 27 minutes ago              chat-e5d9d7c2b898289dfbc5f7f1334140d984eedae4
@@ -243,7 +378,7 @@ From the example above, we can see that `e5d9d7c2b898289dfbc5f7f1334140d984eedae
 
 Note that by default old containers are pruned after 3 days when you run `mrsk deploy`.
 
-### Removing
+### Running removal to clean up servers
 
 If you wish to remove the entire application, including Traefik, containers, images, and registry session, you can run `mrsk remove`. This will leave the servers clean.
 

data/bin/mrsk

@@ -1,5 +1,13 @@
 #!/usr/bin/env ruby
 
+# Prevent failures from being reported twice.
+Thread.report_on_exception = false
+
 require "mrsk/cli"
 
-Mrsk::Cli::Main.start(ARGV)
+begin
+  Mrsk::Cli::Main.start(ARGV)
+rescue SSHKit::Runner::ExecuteError => e
+  puts "  \e[31mERROR (#{e.cause.class}): #{e.cause.message}\e[0m"
+  puts e.cause.backtrace if ENV["VERBOSE"]
+end

data/lib/mrsk/cli/accessory.rb

@@ -0,0 +1,181 @@
+require "mrsk/cli/base"
+
+class Mrsk::Cli::Accessory < Mrsk::Cli::Base
+  desc "boot [NAME]", "Boot accessory service on host (use NAME=all to boot all accessories)"
+  def boot(name)
+    if name == "all"
+      MRSK.accessory_names.each { |accessory_name| boot(accessory_name) }
+    else
+      with_accessory(name) do |accessory|
+        directories(name)
+        upload(name)
+        on(accessory.host) { execute *accessory.run }
+      end
+    end
+  end
+
+  desc "upload [NAME]", "Upload accessory files to host"
+  def upload(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) do
+        accessory.files.each do |(local, remote)|
+          accessory.ensure_local_file_present(local)
+
+          execute *accessory.make_directory_for(remote)
+          upload! local, remote
+          execute :chmod, "755", remote
+        end
+      end
+    end
+  end
+
+  desc "directories [NAME]", "Create accessory directories on host"
+  def directories(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) do
+        accessory.directories.keys.each do |host_path|
+          execute *accessory.make_directory(host_path)
+        end
+      end
+    end
+  end
+
+  desc "reboot [NAME]", "Reboot accessory on host (stop container, remove container, start new container)"
+  def reboot(name)
+    with_accessory(name) do |accessory|
+      stop(name)
+      remove_container(name)
+      boot(name)
+    end
+  end
+
+  desc "start [NAME]", "Start existing accessory on host"
+  def start(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) { execute *accessory.start }
+    end
+  end
+
+  desc "stop [NAME]", "Stop accessory on host"
+  def stop(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) { execute *accessory.stop, raise_on_non_zero_exit: false }
+    end
+  end
+
+  desc "restart [NAME]", "Restart accessory on host"
+  def restart(name)
+    with_accessory(name) do
+      stop(name)
+      start(name)
+    end
+  end
+
+  desc "details [NAME]", "Display details about accessory on host (use NAME=all to boot all accessories)"
+  def details(name)
+    if name == "all"
+      MRSK.accessory_names.each { |accessory_name| details(accessory_name) }
+    else
+      with_accessory(name) do |accessory|
+        on(accessory.host) { puts capture_with_info(*accessory.info) }
+      end
+    end
+  end
+
+  desc "exec [NAME] [CMD]", "Execute a custom command on accessory host"
+  option :run, type: :boolean, default: false, desc: "Start a new container to run the command rather than reusing existing"
+  def exec(name, cmd)
+    with_accessory(name) do |accessory|
+      runner = options[:run] ? :run_exec : :exec
+      on(accessory.host) { |host| puts_by_host host, capture_with_info(*accessory.send(runner, cmd)) }
+    end
+  end
+
+  desc "bash [NAME]", "Start a bash session on primary host (or specific host set by --hosts)"
+  def bash(name)
+    with_accessory(name) do |accessory|
+      run_locally do
+        info "Launching bash session on #{accessory.host}"
+        exec accessory.bash(host: accessory.host)
+      end
+    end
+  end
+
+  desc "logs [NAME]", "Show log lines from accessory on host"
+  option :since, aliases: "-s", desc: "Show logs since timestamp (e.g. 2013-01-02T13:23:37Z) or relative (e.g. 42m for 42 minutes)"
+  option :lines, type: :numeric, aliases: "-n", desc: "Number of log lines to pull from each server"
+  option :grep, aliases: "-g", desc: "Show lines with grep match only (use this to fetch specific requests by id)"
+  option :follow, aliases: "-f", desc: "Follow logs on primary server (or specific host set by --hosts)"
+  def logs(name)
+    with_accessory(name) do |accessory|
+      grep = options[:grep]
+
+      if options[:follow]
+        run_locally do
+          info "Following logs on #{accessory.host}..."
+          info accessory.follow_logs(grep: grep)
+          exec accessory.follow_logs(grep: grep)
+        end
+      else
+        since = options[:since]
+        lines = options[:lines]
+
+        on(accessory.host) do
+          puts capture_with_info(*accessory.logs(since: since, lines: lines, grep: grep))
+        end
+      end
+    end
+  end
+
+  desc "remove [NAME]", "Remove accessory container and image from host (use NAME=all to boot all accessories)"
+  def remove(name)
+    if name == "all"
+      MRSK.accessory_names.each { |accessory_name| remove(accessory_name) }
+    else
+      with_accessory(name) do
+        stop(name)
+        remove_container(name)
+        remove_image(name)
+        remove_service_directory(name)
+      end
+    end
+  end
+
+  desc "remove_container [NAME]", "Remove accessory container from host"
+  def remove_container(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) { execute *accessory.remove_container }
+    end
+  end
+
+  desc "remove_container [NAME]", "Remove accessory image from host"
+  def remove_image(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) { execute *accessory.remove_image }
+    end
+  end
+
+  desc "remove_service_directory [NAME]", "Remove accessory directory used for uploaded files and data directories from host"
+  def remove_service_directory(name)
+    with_accessory(name) do |accessory|
+      on(accessory.host) { execute *accessory.remove_service_directory }
+    end
+  end
+
+  private
+    def with_accessory(name)
+      if accessory = MRSK.accessory(name)
+        yield accessory
+      else
+        error_on_missing_accessory(name)
+      end
+    end
+
+    def error_on_missing_accessory(name)
+      options = MRSK.accessory_names.presence
+
+      error \
+        "No accessory by the name of '#{name}'" +
+        (options ? " (options: #{options.to_sentence})" : "")
+    end
+end