mimas 0.1.0

data/lib/mimas/commands/init.rb

@@ -0,0 +1,63 @@
+module Mimas
+  module CLI
+    module Commands
+      class Init < BaseCommand
+        desc "Create the Mimas config file"
+
+        def call
+          say "Initialising Mimas. We need some information about your site."
+          say ""
+
+          say "Your site's domain will be the containing folder on the server."
+          domain        = ask "What is your site's domain name?"
+          ip            = ask "What is your production server's IP address?"
+          site_type     = ask "Are you creating a \n  1. Ruby app \n  2. Static site \n (1 | 2)"
+          site_type     = site_types[site_type]
+
+          app_server = nil
+          if site_type == :ruby
+            app_server = ask "Which Ruby application server are you using?"
+            app_server&.downcase!
+
+            unless ["falcon", "puma"].include?(app_server)
+              say "Mimas natively supports Falcon and Puma. To use other server, ensure you configure it to bind to a unix socket defined in `ENV['MIMAS_UNIX_SOCKET']`".white.bold
+            end
+          end
+
+          Dir.mkdir("deploy") unless Dir.exist? "deploy"
+
+          destination_dir = File.join(Dir.pwd, Mimas::Config::DEFAULT_DIRECTORY)
+
+          configrb = template("config.rb", ip: ip, domain: domain, site_type: site_type, app_server: app_server)
+          File.write(File.join(destination_dir, "mimas.rb"), configrb)
+
+          if site_type == :ruby
+            copy_file(destination_dir, "Caddyfile.ruby.erb", rename: "Caddyfile.erb")
+
+            if app_server == "falcon"
+              falconrb = template("falcon.rb", domain: domain)
+              File.write(File.join(destination_dir, "falcon.rb"), falconrb)
+            end
+
+            copy_file(destination_dir, "puma.rb") if app_server == "puma"
+          else
+            copy_file(destination_dir, "Caddyfile.static.erb", rename: "Caddyfile.erb")
+          end
+
+          Dir.mkdir("tmp") unless Dir.exist?("tmp")
+
+          say ""
+          say "Successfully created 'deploy/mimas.rb' and 'deploy/Caddyfile.erb'. Customise your deployment by editing these files."
+          say "Please ensure your DNS is correctly configured."
+        end
+
+        def site_types
+          {
+            "1" => :ruby,
+            "2" => :static
+          }
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/install.rb

@@ -0,0 +1,21 @@
+module Mimas
+  module CLI
+    module Commands
+      class Install < BaseCommand
+        desc "Install a new version of Ruby on the server."
+
+        argument :ruby_version, required: true,   desc: "The version of Ruby to install."
+        argument :server_name,  required: true,   desc: "The name of the server to install Ruby on"
+
+        example [
+          "4.0.5 production"
+        ]
+
+        def call(ruby_version:, server_name:)
+          server = Config.current.servers[server_name.to_sym]
+          server.install_ruby(version: ruby_version)
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/provision.rb

@@ -0,0 +1,50 @@
+module Mimas
+  module CLI
+    module Commands
+      class Provision < BaseCommand
+        desc "Provision the remote server by applying security settings, creating users, and installing Caddy and Ruby. Requires root access."
+
+        argument :server_name,  required: true,   desc: "The name of the server to provision"
+
+        option :user, default: "admin", aliases: ["-u"], desc: "A user with sudo access"
+        option :skip_ruby, default: false, type: :flag, desc: "Skip the installation of Ruby and its prerequisites. Use when only serving static sites"
+
+        example [
+          "production                         # Provision the production server",
+          "production -u administrator        # Specify the sudo user as 'administrator'",
+          "--skip-ruby                        # Skip Ruby and install only Caddy"
+        ]
+
+        def call(server_name:, **options)
+          server = Config.current.servers[server_name.to_sym]
+          sudo_user = options[:user]
+          skip_ruby = options[:skip_ruby]
+
+          server.harden
+
+          say "Waiting for server to come back online ..."
+          sleep 30
+
+          connection_retries = 0
+          begin
+            connection_retries += 1
+            Net::SSH.start(server.host, sudo_user, **server.ssh_options)&.close
+          rescue
+            sleep 5
+            retry if connection_retries < 5
+            say "Unable to re-connect to server."
+            say "Wait for the server to come online, then run `bin/mimas setup`"
+          end
+
+          server.setup_deploy_user(sudo_user: sudo_user)
+          server.install_caddy(sudo_user: sudo_user)
+
+          unless skip_ruby
+            server.install_ruby_prerequisites(sudo_user: sudo_user)
+            server.install_ruby
+          end
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/push.rb

@@ -0,0 +1,28 @@
+module Mimas
+  module CLI
+    module Commands
+      class Push < BaseCommand
+        desc "Push your Ruby app to the server"
+
+        argument :server_name,  required: true,   desc: "The name of the server to push to"
+        argument :site,                           desc: "The site to push. Uses the default site if unspecified"
+
+        example [
+          "production                         # Push the default site to the production server",
+          "production app                     # Push the `:app` site to the production server"
+        ]
+
+        def call(server_name:, site: :default)
+          server  = Config.current.servers[server_name.to_sym]
+          site    = Config.current.sites[site.to_sym]
+
+          @hooks[:before_push].each { it.call }
+
+          Deployment.new(site: site, server: server).deploy
+
+          @hooks[:after_push].each { it.call }
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/setup/caddy.rb

@@ -0,0 +1,18 @@
+module Mimas
+  module CLI
+    module Commands
+      class Setup::Caddy < Setup
+        desc "Setup Caddy on a server"
+
+        option :user, default: "admin", aliases: ["-u"], desc: "A user with sudo access. Defaults to 'admin'"
+
+        def call(server_name:, **options)
+          server = Config.current.servers[server_name.to_sym]
+          sudo_user = options[:user]
+
+          server.install_caddy(sudo_user: sudo_user)
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/setup/deploy_user.rb

@@ -0,0 +1,16 @@
+module Mimas
+  module CLI
+    module Commands
+      class Setup::DeployUser < Setup
+        desc "Create a deployment user as defined in your config file on a server"
+
+        def call(server_name:, **options)
+          server = Config.current.servers[server_name.to_sym]
+          sudo_user = options[:user]
+
+          server.setup_deploy_user(sudo_user: sudo_user)
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/setup/ruby.rb

@@ -0,0 +1,17 @@
+module Mimas
+  module CLI
+    module Commands
+      class Setup::Ruby < Setup
+        desc "Install Ruby prerequisites and build a Ruby binary on a server"
+
+        def call(server_name:, **options)
+          server = Config.current.servers[server_name.to_sym]
+          sudo_user = options[:user]
+
+          server.install_ruby_prerequisites(sudo_user: sudo_user)
+          server.install_ruby
+        end
+      end
+    end
+  end
+end

data/lib/mimas/commands/setup.rb

@@ -0,0 +1,10 @@
+module Mimas
+  module CLI
+    module Commands
+      class Setup < BaseCommand
+        argument :server_name,  required: true,   desc: "The name of the server to setup"
+        option :user, default: "admin", aliases: ["-u"], desc: "A user with sudo access"
+      end
+    end
+  end
+end

data/lib/mimas/config.rb

@@ -0,0 +1,124 @@
+module Mimas
+  class Config
+    DEFAULT_DIRECTORY = "deploy"
+
+    def self.current
+      @current ||= load
+    end
+
+    def self.load(path = File.join(Dir.pwd, DEFAULT_DIRECTORY, "mimas.rb"))
+      if File.exist?(path)
+        source = File.read(path)
+        @current = build(source)
+      end
+    end
+
+    def self.open(&block)
+      DSL.new(&block).config
+    end
+
+    def self.build(source)
+      DSL.new(source).config
+    end
+
+    attr_reader :sites, :servers, :hooks
+
+    def initialize
+      @sites        = {}
+      @servers      = {}
+      @hooks        = Hooks.new
+    end
+
+    def ruby_version
+      @ruby_version ||= begin
+        File.read(File.join(Dir.pwd, ".ruby-version")).chomp
+      rescue Errno::ENOENT
+        RUBY_VERSION
+      end
+    end
+
+    private
+
+      class DSL
+        attr_reader :config
+
+        def initialize(source = nil, &block)
+          @config = Config.new
+
+          if source
+            instance_eval(source)
+          else
+            instance_exec(&block)
+          end
+        end
+
+        def site(name = :default, &block)
+          name = name.to_sym
+          args = Site.evaluate(&block)
+          @config.sites[name] = Mimas::Site.new(name, args)
+        end
+
+        def server(name, &block)
+          name = name.to_sym
+          args = Options.evaluate(&block)
+          @config.servers[name] = Mimas::Server.new(name, args)
+        end
+
+        def hooks(&block)
+          @config.hooks.instance_exec(&block)
+        end
+      end
+
+      class Options
+        def self.evaluate(&block)
+          evaluator = self.new
+          evaluator.instance_exec(&block)
+          evaluator.options
+        end
+
+        attr_reader :options
+
+        def initialize
+          @options = {}
+        end
+
+        def method_missing(name, *args, &block)
+          if block
+            @options[name.to_sym] = block.call
+          else
+            @options[name.to_sym] = args.first
+          end
+        end
+      end
+
+      class Site < Options
+        def services(&block)
+          @options[:services] = Services.parse(&block)
+        end
+
+        def deploy(&block)
+          @options[:deploy] = block.call.to_s
+        end
+      end
+
+      class Services
+        def self.parse(&block)
+          services_parser = self.new
+          services_parser.instance_exec(&block)
+          services_parser.services
+        end
+
+        attr_reader :services
+        def initialize
+          @services = {}
+        end
+
+        def method_missing(name, *args, &block)
+          @services[name] = Options.evaluate do
+            instance_eval(&block)
+          end
+          @services[name][:name] = name
+        end
+      end
+  end
+end

data/lib/mimas/deployment/caddy.rb

@@ -0,0 +1,39 @@
+module Mimas
+  class Deployment
+    module Caddy
+      def refreshing_caddy(session, &block)
+        session.run "mkdir -p #{remote_destination}"
+        session.upload StringIO.new(commit_hash), remote_destination.join("commit-sha")
+
+        remote_caddyfile = ""
+        begin
+          remote_caddyfile = session.run "cat #{caddyfile_path}", capture: true
+        rescue SSH::Session::NonZeroExitCode
+          # Ignore non-zero exit
+        end
+        caddyfile_modified = remote_caddyfile != caddyfile
+
+        if caddyfile_modified
+          say "Uploading new Caddyfile"
+          begin
+            session.upload StringIO.new(caddyfile), new_caddyfile_path
+            session.run "caddy validate --config #{new_caddyfile_path}", capture: true
+            say "New Caddyfile validated"
+          rescue SSH::Session::NonZeroExitCode
+            session.run "rm #{new_caddyfile_path}"
+            say caddyfile.bold.red
+            raise "Your Caddyfile is invalid"
+          end
+        end
+
+        yield
+
+        if caddyfile_modified
+          say "Updating Caddyfile and reloading Caddy"
+          session.run "mv #{new_caddyfile_path} #{caddyfile_path}"
+          session.run "sudo systemctl reload caddy"
+        end
+      end
+    end
+  end
+end

data/lib/mimas/deployment/files.rb

@@ -0,0 +1,51 @@
+module Mimas
+  class Deployment
+    module Files
+      CADDYFILE_PATH = Pathname(Dir.pwd).join(Mimas::Config::DEFAULT_DIRECTORY)
+
+      def caddyfile
+        @caddyfile ||= begin
+          file_name = ["Caddyfile", site.name, "erb"].reject { it == :default }.join(".")
+          ERB.new(File.read(CADDYFILE_PATH.join(file_name)))
+            .result_with_hash(
+              site: site,
+              server: server,
+              domain: site.domain,
+              site_root: site_root,
+              unix_socket: unix_socket
+            )
+        end
+      end
+
+      def systemd_service_name(service, version: self.version)
+        return nil if site.static?
+
+        "#{site.domain}--#{service[:name]}--#{version}"
+      end
+
+      def systemd(service)
+        return nil if site.static?
+
+        template("systemd.service",
+          domain: site.domain,
+          version: version,
+          user: server.user,
+          site_root: site_root,
+          service_name: service[:name],
+          command: service[:command],
+        )
+      end
+
+      def mimas_env
+        return nil if site.static?
+
+        @mimas_env ||=
+          template("mimas.env", unix_socket: unix_socket, env: site.env)
+      end
+
+      def deploy_script
+        ".mimas_deploy.sh"
+      end
+    end
+  end
+end

data/lib/mimas/deployment/paths.rb

@@ -0,0 +1,54 @@
+module Mimas
+  class Deployment
+    module Paths
+      def remote_destination
+        @remote_destination ||= releases_path.join(version)
+      end
+
+      def archive_name
+        @archive_name ||= "#{site.name}--#{version}.tar.gz"
+      end
+
+      def archive_path
+        @archive_path ||= File.join(Dir.pwd, "tmp", archive_name)
+      end
+
+      def site_root
+        server.site_root(site)
+      end
+
+      def current_path
+        server.current_path(site)
+      end
+
+      def caddyfile_path
+        site_root.join("Caddyfile")
+      end
+
+      def new_caddyfile_path
+        site_root.join("Caddyfile.new")
+      end
+
+      def mimas_path
+        site_root.join("mimas")
+      end
+
+      def releases_path
+        site_root.join("releases")
+      end
+
+      def unix_socket(version: self.version)
+        return nil if site.static?
+        mimas_path.join("application--#{version}.sock")
+      end
+
+      def ruby_version
+        Config.current.ruby_version
+      end
+
+      def deploy_script_path
+        remote_destination.join(deploy_script)
+      end
+    end
+  end
+end

data/lib/mimas/deployment/ruby_app.rb

@@ -0,0 +1,126 @@
+module Mimas
+  class Deployment
+    module RubyApp
+      def deploy_ruby_app
+        say "Starting deployment for #{site.domain}"
+
+        archive(output: archive_path, files: site.files)
+
+        ssh(server) do |session|
+          begin
+            session.run "test -d ~/.rubies/ruby-#{ruby_version}"
+            say "Ruby #{ruby_version} found on the server..."
+          rescue SSH::Session::NonZeroExitCode
+            raise "Ruby version not installed on server"
+          end
+
+          # Create the release folder
+          session.run "mkdir -p #{releases_path}"
+
+          # Get expired releases. Mimas will only retain the last 5 releases.
+          releases = session.run "ls #{releases_path}", capture: true
+          expired_releases = releases.split("\n").sort.reverse.drop(5)
+
+          if expired_releases.any?
+            say "Deleting versions: #{expired_releases.join(", ")}"
+            session.run "cd #{releases_path} && rm -rf #{expired_releases.join(" ")}"
+          end
+
+          # Check `current` symlink to get currently live version
+          remote_current_path = session.run("readlink #{current_path}", capture: true, silent: true).chomp
+          remote_current_version = Pathname.new(remote_current_path).basename.to_s.chomp
+
+          say "Current live version is #{remote_current_version}" if remote_current_version.size > 0
+
+          # Make systemd path and the site's mimas folder
+          session.run "mkdir -p #{server.user_systemd_path}"
+          session.run "mkdir -p #{mimas_path}"
+
+          refreshing_caddy(session) do
+            # Upload the mimas.env and touch an `.env` file in the site's root
+            session.upload StringIO.new(mimas_env), mimas_path.join("mimas.env")
+            session.run "touch #{site_root.join(".env")}"
+
+            say "Uploading version: #{version}"
+            session.upload archive_path, "#{remote_destination}/"
+
+            say "Extracting version: #{version}"
+            session.run "cd #{remote_destination} && tar -xf #{archive_name} && rm #{archive_name}", capture: true
+
+            say "Running deploy script"
+            session.upload StringIO.new(site.deploy), deploy_script_path
+            session.run "cd #{remote_destination} && /usr/bin/env bash -l #{deploy_script}"
+            session.run "rm #{deploy_script_path}"
+
+            say "Setting current symlink"
+            session.run "ln -sfn #{remote_destination} #{current_path}"
+            say "Current symlink set"
+
+            site.services.each do |_, service|
+              say "Installing service: #{service[:name]}"
+              systemd_service_name = systemd_service_name(service)
+              system_contents = systemd(service)
+
+              session.upload StringIO.new(system_contents), server.user_systemd_path.join("#{systemd_service_name}.service")
+              session.run "systemctl --user enable --now #{systemd_service_name}", capture: true
+              say "Started #{service[:name]} service using as #{systemd_service_name}"
+
+              begin
+                say "Health checking new service"
+                session.run "curl --max-time 1 --silent --fail --unix-socket #{unix_socket} http://localhost#{site.healthcheck_path}", capture: true
+                say "Health check succeeded"
+              rescue SSH::Session::NonZeroExitCode => e
+                say "Health check failed".red
+                say e.to_s.red.bold
+                raise e
+              end
+            end
+          rescue Exception => e
+            say "Error raised during deploy: #{e}".red.bold
+
+            # Revert symlink if there's an existing live release, otherwise delete it
+            if remote_current_path.size > 0
+              say "Reverting symlink ..."
+              session.run "ln -sfn #{remote_current_path} #{current_path}"
+            else
+              say "Deleting symlink ..."
+              session.run "rm -f #{current_path}"
+            end
+
+            say "Deleting released files ..."
+
+            site.services.each do |_, service|
+              systemd_service_name = systemd_service_name(service)
+              session.run "systemctl --user stop #{systemd_service_name}", silent: true, capture: true
+              session.run "systemctl --user disable #{systemd_service_name}", silent: true, capture: true
+              session.run "rm #{server.user_systemd_path.join("#{systemd_service_name}.service")}", silent: true
+            end
+
+            session.run "rm -f #{unix_socket(version: version)}"
+            session.run "rm -f #{site_root.join("Caddyfile.new")}"
+            session.run "rm -rf #{remote_destination}"
+
+            exit 1
+          end
+
+          # Delete the old service if one exists, and the new service started up
+          if remote_current_version.size > 0
+            site.services.each do |_, service|
+              systemd_service_name = systemd_service_name(service, version: remote_current_version)
+
+              say "Stopping old service: #{systemd_service_name}"
+              session.run "systemctl --user stop #{systemd_service_name}"
+              session.run "systemctl --user disable #{systemd_service_name}"
+              session.run "rm #{server.user_systemd_path.join("#{systemd_service_name}.service")}"
+              say "#{systemd_service_name} stopped and deleted."
+              session.run "rm -f #{unix_socket(version: remote_current_version)}"
+            end
+          end
+
+          say "\n"
+          say "Deployment complete! #{version} is now live.".bold.white
+        end
+      end
+    end
+  end
+end

data/lib/mimas/deployment/static_site.rb

@@ -0,0 +1,28 @@
+module Mimas
+  class Deployment
+    module StaticSite
+      def deploy_static_site
+        say "Starting deployment for #{site.domain}"
+
+        archive(root: site.root_dir, output: archive_path, archive_root: "root", glob: site.glob)
+
+        ssh(server) do |session|
+          refreshing_caddy(session) do
+            say "Uploading version: #{version}"
+            session.upload archive_path, "#{remote_destination}/"
+
+            say "Extracting version: #{version}"
+            session.run "cd #{remote_destination} && tar -xf #{archive_name} && rm #{archive_name}"
+
+            say "Updating current symlink"
+            session.run "ln -sfn #{remote_destination} #{current_path}"
+            say "Current symlink updated"
+          end
+        end
+
+        say "\n\n"
+        say "Deployment complete! #{version} is now live.".bold.white
+      end
+    end
+  end
+end

data/lib/mimas/deployment.rb

@@ -0,0 +1,27 @@
+module Mimas
+  class Deployment
+    include Terminal::Printer, Template, Archive, SSH
+
+    include Paths, Files
+    include StaticSite, RubyApp, Caddy
+
+    attr_reader :site, :server, :version, :commit_hash
+
+    def initialize(site:, server:)
+      @site = site
+      @server = server
+      @version = Time.now.utc.strftime("%Y%m%d%H%M%S")
+      @commit_hash = `git rev-parse HEAD`
+    end
+
+    def deploy
+      if site.static?
+        deploy_static_site
+      else
+        deploy_ruby_app
+      end
+    ensure
+      File.delete(archive_path)
+    end
+  end
+end