bard 2.0.0.beta → 2.0.0

data/lib/bard/provision/deploy.rb

@@ -1,10 +0,0 @@
-# run bard deploy
-
-class Bard::Provision::Deploy < Bard::Provision
-  def call
-    print "Deploy:"
-    provision_server.run! "bin/setup"
-    puts " ✓"
-  end
-end
-

data/lib/bard/provision/http.rb

@@ -1,16 +0,0 @@
-require "uri"
-
-# test for existence
-
-class Bard::Provision::HTTP < Bard::Provision
-  def call
-    print "HTTP:"
-    target_host = URI.parse(server.ping.first).host
-    if system "curl -s --resolve #{target_host}:80:#{provision_server.ssh_uri.host} http://#{target_host} -I | grep -i \"x-powered-by: phusion passenger\" >/dev/null 2>&1"
-      puts " ✓"
-    else
-      puts " !!! not serving a rails app from #{provision_server.ssh_uri.host}"
-    end
-  end
-end
-

data/lib/bard/provision/logrotation.rb

@@ -1,30 +0,0 @@
-# install log rotation if missing
-
-class Bard::Provision::LogRotation < Bard::Provision
-  def call
-    print "Log Rotation:"
-
-    provision_server.run! <<~SH, quiet: true
-      file=/etc/logrotate.d/#{server.project_name}
-      if [ ! -f $file ]; then
-        sudo tee $file > /dev/null <<EOF
-      $(pwd)/log/*.log {
-        weekly
-        size 100M
-        missingok
-        rotate 52
-        delaycompress
-        notifempty
-        copytruncate
-        create 664 www www
-      }
-      EOF
-      fi
-    SH
-
-    puts " ✓"
-  end
-end
-
-
-

data/lib/bard/provision/masterkey.rb

@@ -1,18 +0,0 @@
-require "bard/copy"
-
-# copy master key if missing
-
-class Bard::Provision::MasterKey < Bard::Provision
-  def call
-    print "Master Key:"
-    if File.exist?("config/master.key")
-      if !provision_server.run "[ -f config/master.key ]", quiet: true
-        print " Uploading config/master.key,"
-        Bard::Copy.new("config/master.key").scp_using_local(:to, provision_server)
-      end
-    end
-
-    puts " ✓"
-  end
-end
-

data/lib/bard/provision/mysql.rb

@@ -1,22 +0,0 @@
-# install mysql
-
-class Bard::Provision::MySQL < Bard::Provision
-  def call
-    print "MySQL:"
-    if !mysql_responding?
-      print " Installing,"
-      provision_server.run! [
-        "sudo apt-get install -y mysql-server",
-        %(sudo mysql -uroot -e "ALTER USER \\"'\\"root\\"'\\"@\\"'\\"localhost\\"'\\" IDENTIFIED WITH mysql_native_password BY \\"'\\"\\"'\\", \\"'\\"root\\"'\\"@\\"'\\"localhost\\"'\\" PASSWORD EXPIRE NEVER; FLUSH PRIVILEGES;"),
-        %(mysql -uroot -e "UPDATE mysql.user SET password_lifetime = NULL WHERE user = \\"'\\"root\\"'\\" AND host = \\"'\\"localhost\\"'\\";"),
-      ].join("; "), home: true
-    end
-
-    puts " ✓"
-  end
-
-  def mysql_responding?
-    provision_server.run "sudo systemctl is-active --quiet mysql", home: true, quiet: true
-  end
-end
-

data/lib/bard/provision/passenger.rb

@@ -1,37 +0,0 @@
-# install nginx & passenger
-
-class Bard::Provision::Passenger < Bard::Provision
-  def call
-    print "Passenger:"
-    if !http_responding?
-      print " Installing nginx & Passenger,"
-      provision_server.run! [
-        %(grep -qxF "RAILS_ENV=production" /etc/environment || echo "RAILS_ENV=production" | sudo tee -a /etc/environment),
-        %(grep -qxF "EDITOR=vim" /etc/environment || echo "EDITOR=vim" | sudo tee -a /etc/environment),
-        "sudo apt-get install -y vim dirmngr gnupg apt-transport-https ca-certificates",
-        "curl https://oss-binaries.phusionpassenger.com/auto-software-signing-gpg-key.txt | gpg --dearmor | sudo tee /etc/apt/trusted.gpg.d/phusion.gpg >/dev/null",
-        %(echo "deb https://oss-binaries.phusionpassenger.com/apt/passenger jammy main" | sudo tee /etc/apt/sources.list.d/passenger.list),
-        "sudo apt-get update -y",
-        "sudo apt-get install -y nginx libnginx-mod-http-passenger",
-        "sudo rm /etc/nginx/sites-enabled/default",
-      ].join("; "), home: true
-    end
-
-    if !app_configured?
-      print " Creating nginx config for app,"
-      provision_server.run! "bard setup"
-    end
-
-    puts " ✓"
-  end
-
-  def http_responding?
-    system "nc -zv #{provision_server.ssh_uri.host} 80 2>/dev/null"
-  end
-
-  def app_configured?
-    provision_server.run "[ -f /etc/nginx/sites-enabled/#{server.project_name} ]", quiet: true
-  end
-end
-
-

data/lib/bard/provision/repo.rb

@@ -1,72 +0,0 @@
-require "bard/github"
-
-# generate and install ssh public key into deploy keys
-# add repo to known hosts
-# clone repo
-
-class Bard::Provision::Repo < Bard::Provision
-  def call
-    print "Repo:"
-    if !already_cloned?
-      if !can_clone_project?
-        if !ssh_keypair?
-          print " Generating keypair in ~/.ssh,"
-          provision_server.run! "ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -q -N \"\"", home: true
-        end
-        print " Add public key to GitHub repo deploy keys,"
-        title = "#{server.ssh_uri.user}@#{server.ssh_uri.host}"
-        key = provision_server.run "cat ~/.ssh/id_rsa.pub", home: true
-        Bard::Github.new(server.project_name).add_deploy_key title:, key:
-      end
-      print " Cloning repo,"
-      provision_server.run! "git clone git@github.com:botandrosedesign/#{project_name}", home: true
-    else
-      if !on_latest_master?
-        print " Updating to latest master,"
-        update_to_latest_master!
-      end
-    end
-
-    puts " ✓"
-  end
-
-  private
-
-  def ssh_keypair?
-    provision_server.run "[ -f ~/.ssh/id_rsa.pub ]", home: true, quiet: true
-  end
-
-  def already_cloned?
-    provision_server.run "[ -d ~/#{project_name}/.git ]", home: true, quiet: true
-  end
-
-  def can_clone_project?
-    github_url = "git@github.com:botandrosedesign/#{project_name}"
-    provision_server.run [
-      "needle=$(ssh-keyscan -t ed25519 github.com 2>/dev/null | cut -d \" \" -f 2-3)",
-      "grep -q \"$needle\" ~/.ssh/known_hosts || ssh-keyscan -H github.com >> ~/.ssh/known_hosts 2>/dev/null",
-      "git ls-remote #{github_url}",
-    ].join("; "), home: true, quiet: true
-  end
-
-  def project_name
-    server.project_name
-  end
-
-  def on_latest_master?
-    provision_server.run [
-      "cd ~/#{project_name}",
-      "git fetch origin",
-      "[ $(git rev-parse HEAD) = $(git rev-parse origin/master) ]"
-    ].join(" && "), home: true, quiet: true
-  end
-
-  def update_to_latest_master!
-    provision_server.run! [
-      "cd ~/#{project_name}",
-      "git checkout master",
-      "git reset --hard origin/master"
-    ].join(" && "), home: true
-  end
-end
-

data/lib/bard/provision/rvm.rb

@@ -1,22 +0,0 @@
-# install rvm if missing
-
-class Bard::Provision::RVM < Bard::Provision
-  def call
-    print "RVM:"
-    if !provision_server.run "[ -d ~/.rvm ]", quiet: true
-      print " Installing RVM,"
-      provision_server.run! [
-        %(sed -i "1i[[ -s \\"$HOME/.rvm/scripts/rvm\\" ]] && source \\"$HOME/.rvm/scripts/rvm\\" # Load RVM into a shell session *as a function*" ~/.bashrc),
-        "gpg --keyserver keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDB",
-        "curl -sSL https://get.rvm.io | bash -s stable",
-      ].join("; ")
-      version = File.read(".ruby-version").chomp
-      print " Installing Ruby #{version},"
-      provision_server.run! "rvm install #{version}"
-    end
-
-    puts " ✓"
-  end
-end
-
-

data/lib/bard/provision/ssh.rb

@@ -1,72 +0,0 @@
-# move ssh port
-# add to known hosts
-
-class Bard::Provision::SSH < Bard::Provision
-  def call
-    print "SSH:"
-
-    if password_auth_enabled?
-      print " Disabling password authentication,"
-      disable_password_auth!
-    end
-
-    if !ssh_available?(provision_server.ssh_uri, port: target_port)
-      if !ssh_available?(provision_server.ssh_uri)
-        raise "can't find SSH on port #{target_port} or #{provision_server.ssh_uri.port || 22}"
-      end
-      if !ssh_known_host?(provision_server.ssh_uri)
-        print " Adding known host,"
-        add_ssh_known_host!(provision_server.ssh_uri)
-      end
-      print " Reconfiguring port to #{target_port},"
-      provision_server.run! %(echo "Port #{target_port}" | sudo tee /etc/ssh/sshd_config.d/port_#{target_port}.conf; sudo service ssh restart), home: true
-    end
-
-    if !ssh_known_host?(provision_server.ssh_uri)
-      print " Adding known host,"
-      add_ssh_known_host!(provision_server.ssh_uri)
-    end
-
-    # provision with new target port from now on
-    ssh_url.gsub!(/:\d+$/, "")
-    ssh_url << ":#{target_port}"
-    puts " ✓"
-  end
-
-  private
-
-  def target_port
-    server.ssh_uri.port || 22
-  end
-
-  def ssh_available? ssh_uri, port: nil
-    port ||= ssh_uri.port || 22
-    system "nc -zv #{ssh_uri.host} #{port} 2>/dev/null"
-  end
-
-  def ssh_known_host? ssh_uri
-    port ||= ssh_uri.port || 22
-    system "grep -q \"$(ssh-keyscan -t ed25519 -p#{port} #{ssh_uri.host} 2>/dev/null | cut -d ' ' -f 2-3)\" ~/.ssh/known_hosts"
-  end
-
-  def add_ssh_known_host! ssh_uri
-    port ||= ssh_uri.port || 22
-    system "ssh-keyscan -p#{port} -H #{ssh_uri.host} >> ~/.ssh/known_hosts 2>/dev/null"
-  end
-
-  def password_auth_enabled?
-    result = provision_server.run!(
-      %q{grep -E '^\s*PasswordAuthentication\s+yes' /etc/ssh/sshd_config /etc/ssh/sshd_config.d/*.conf 2>/dev/null || true},
-      home: true,
-      capture: true
-    )
-    !!(result && !result.strip.empty?)
-  end
-
-  def disable_password_auth!
-    provision_server.run!(
-      %q{echo "PasswordAuthentication no" | sudo tee /etc/ssh/sshd_config.d/disable_password_auth.conf; sudo service ssh restart},
-      home: true
-    )
-  end
-end

data/lib/bard/provision/swapfile.rb

@@ -1,21 +0,0 @@
-# setup swapfile
-
-class Bard::Provision::Swapfile < Bard::Provision
-  def call
-    print "Swapfile:"
-
-    provision_server.run! <<~SH
-      if [ ! -f /swapfile ]; then
-        sudo fallocate -l $(grep MemTotal /proc/meminfo | awk '{print $2}')K /swapfile
-      fi
-      sudo chmod 600 /swapfile
-      sudo swapon --show | grep -q '/swapfile' || sudo mkswap /swapfile
-      sudo swapon --show | grep -q '/swapfile' || sudo swapon /swapfile
-      grep -q '/swapfile none swap sw 0 0' /etc/fstab || echo '/swapfile none swap sw 0 0' | sudo tee -a /etc/fstab
-    SH
-
-    puts " ✓"
-  end
-end
-
-

data/lib/bard/provision/user.rb

@@ -1,42 +0,0 @@
-# rename user
-
-class Bard::Provision::User < Bard::Provision
-  def call
-    print "User:"
-
-    if !ssh_with_user?(provision_server.ssh_uri, user: new_user)
-      if !ssh_with_user?(provision_server.ssh_uri)
-        raise "can't ssh in with user #{new_user} or #{old_user}"
-      end
-      print " Adding user #{new_user},"
-      provision_server.run! [
-        "sudo useradd -m -s /bin/bash #{new_user}",
-        "sudo usermod -aG sudo #{new_user}",
-        "echo \"#{new_user} ALL=(ALL) NOPASSWD:ALL\" | sudo tee -a /etc/sudoers",
-        "sudo mkdir -p ~#{new_user}/.ssh",
-        "sudo cp ~/.ssh/authorized_keys ~#{new_user}/.ssh/authorized_keys",
-        "sudo chown -R #{new_user}:#{new_user} ~#{new_user}/.ssh",
-        "sudo chmod +rx ~#{new_user}", # so nginx and passenger can read it
-      ].join("; "), home: true
-    end
-
-    # provision with new user from now on
-    ssh_url.gsub!("#{old_user}@", "#{new_user}@")
-    puts " ✓"
-  end
-
-  private
-
-  def new_user
-    server.ssh_uri.user
-  end
-
-  def old_user
-    provision_server.ssh_uri.user
-  end
-
-  def ssh_with_user? ssh_uri, user: ssh_uri.user
-    system "ssh -o ConnectTimeout=2 -p#{ssh_uri.port || 22} #{user}@#{ssh_uri.host} : >/dev/null 2>&1"
-  end
-end
-

data/lib/bard/provision.rb

@@ -1,16 +0,0 @@
-module Bard
-  class Provision < Struct.new(:config, :ssh_url)
-    def self.call(...) = new(...).call
-
-    private
-
-    def server
-      config[:production]
-    end
-
-    def provision_server
-      server.with(ssh: ssh_url)
-    end
-  end
-end
-

data/lib/bard/server.rb

@@ -1,117 +0,0 @@
-require "uri"
-require "bard/command"
-require "bard/copy"
-
-module Bard
-  class Server < Struct.new(:project_name, :key, :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages)
-    def self.define project_name, key, &block
-      new(project_name, key).tap do |server|
-        server.instance_eval &block
-      end
-    end
-
-    def self.setting *fields
-      fields.each do |field|
-        define_method field do |*args|
-          if args.length == 1
-            send :"#{field}=", args.first
-          elsif args.length == 0
-            super()
-          else
-            raise ArgumentError
-          end
-        end
-      end
-    end
-
-    setting :ssh, :path, :ping, :gateway, :ssh_key, :env, :github_pages
-
-    def ping(*args)
-      if args.length == 0
-        (super() || [nil]).map(&method(:normalize_ping)).flatten
-      else
-        self.ping = args
-      end
-    end
-
-    private def normalize_ping value
-      return [] if value == false
-      normalized = "https://#{ssh_uri.host}" # default if none specified
-      if value =~ %r{^/}
-        normalized += value
-      elsif value.to_s.length > 0
-        normalized = value
-      end
-      if normalized !~ /^http/
-        normalized = "https://#{normalized}"
-      end
-      normalized
-    end
-
-    def path(*args)
-      if args.length == 1
-        self.path = args.first
-      elsif args.length == 0
-        super() || project_name
-      else
-        raise ArgumentError
-      end
-    end
-
-    def ssh_uri which=:ssh
-      value = send(which)
-      URI("ssh://#{value}")
-    end
-
-    def scp_uri file_path=nil
-      ssh_uri.dup.tap do |uri|
-        uri.scheme = "scp"
-        uri.path = "/#{path}"
-        uri.path += "/#{file_path}" if file_path
-      end
-    end
-
-    def rsync_uri file_path=nil
-      str = ssh_uri.dup.tap do |uri|
-        uri.send :set_scheme, nil
-        uri.send :set_port, nil
-      end.to_s[2..]
-      str += ":#{path}"
-      str += "/#{file_path}" if file_path
-      str
-    end
-
-    def with(attrs)
-      dup.tap do |s|
-        attrs.each do |key, value|
-          s.send key, value
-        end
-      end
-    end
-
-    def to_sym
-      key
-    end
-
-    def run! command, home: false, verbose: false, quiet: false
-      Bard::Command.run! command, on: self, home:, verbose:, quiet:
-    end
-
-    def run command, home: false, verbose: false, quiet: false
-      Bard::Command.run command, on: self, home:, verbose:, quiet:
-    end
-
-    def exec! command, home: false
-      Bard::Command.exec! command, on: self, home:
-    end
-
-    def copy_file path, to:, verbose: false
-      Bard::Copy.file path, from: self, to:, verbose:
-    end
-
-    def copy_dir path, to:, verbose: false
-      Bard::Copy.dir path, from: self, to:, verbose:
-    end
-  end
-end
-

data/spec/bard/cli/command_spec.rb

@@ -1,50 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/command"
-
-class TestCommand < Bard::CLI::Command
-  desc "test_command", "test command description"
-  option :verbose, type: :boolean
-
-  def test_command
-    "executed"
-  end
-end
-
-describe Bard::CLI::Command do
-  let(:cli_mock) { double("cli") }
-  let(:command) { TestCommand.new(cli_mock) }
-
-  describe ".desc" do
-    it "sets command and description" do
-      expect(TestCommand.instance_variable_get(:@command)).to eq("test_command")
-      expect(TestCommand.instance_variable_get(:@description)).to eq("test command description")
-    end
-  end
-
-  describe ".option" do
-    it "sets option arguments" do
-      expect(TestCommand.instance_variable_get(:@option_args)).to eq([:verbose])
-      expect(TestCommand.instance_variable_get(:@option_kwargs)).to eq({type: :boolean})
-    end
-  end
-
-  describe ".setup" do
-    let(:cli_double) { double("cli") }
-
-    it "sets up the command on the CLI class" do
-      expect(cli_double).to receive(:desc).with("test_command", "test command description")
-      expect(cli_double).to receive(:option).with(:verbose, type: :boolean)
-      expect(cli_double).to receive(:define_method)
-
-      TestCommand.setup(cli_double)
-    end
-  end
-
-  describe "delegation" do
-    it "should delegate to the wrapped object" do
-      allow(cli_mock).to receive(:some_method).and_return("delegated")
-      expect(command.some_method).to eq("delegated")
-    end
-  end
-end

data/spec/bard/cli/new_spec.rb

@@ -1,73 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/new"
-
-describe Bard::CLI::New do
-  let(:new_cli) { Bard::CLI::New.new(double("cli")) }
-
-  before do
-    allow(new_cli).to receive(:puts)
-    allow(new_cli).to receive(:exit)
-    allow(new_cli).to receive(:run!)
-    allow(new_cli).to receive(:green).and_return("")
-    allow(new_cli).to receive(:red).and_return("")
-    allow(new_cli).to receive(:yellow).and_return("")
-    allow(File).to receive(:read).and_return("master_key_content")
-  end
-
-  describe "#new" do
-    context "with invalid project name" do
-      before do
-        allow(new_cli).to receive(:create_project)
-        allow(new_cli).to receive(:push_to_github)
-        allow(new_cli).to receive(:stage)
-      end
-
-      it "should reject names starting with uppercase" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("InvalidProject")
-      end
-
-      it "should reject names with special characters" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("invalid-project")
-      end
-
-      it "should reject names starting with numbers" do
-        expect(new_cli).to receive(:puts).with(/Invalid project name/)
-        expect(new_cli).to receive(:exit).with(1)
-
-        new_cli.new("1invalidproject")
-      end
-    end
-  end
-
-  describe "#ruby_version" do
-    it "returns the ruby version" do
-      expect(new_cli.send(:ruby_version)).to eq("ruby-3.4.2")
-    end
-  end
-
-  describe "#template_path" do
-    it "returns the path to the rails template" do
-      expect(new_cli.send(:template_path)).to match(/new_rails_template\.rb$/)
-    end
-  end
-
-  describe "#install_and_extract_version" do
-    it "correctly installs a gem and extracts its version", skip: !!ENV["CI"] do
-      cmd = new_cli.send :build_bash_env do
-        <<~SH
-          #{new_cli.send(:build_gem_install, "bundler", "~> 2.0")}
-          echo ${GEM_VERSION}
-        SH
-      end
-      result = `#{cmd}`.strip
-      expect(result).to match(/^2\.\d+\.\d+/)
-    end
-  end
-end

data/spec/bard/cli/provision_spec.rb

@@ -1,42 +0,0 @@
-require "spec_helper"
-require "bard/cli"
-require "bard/cli/provision"
-
-describe Bard::CLI::Provision do
-  let(:config) { { production: double("production", ssh: "user@example.com") } }
-  let(:provision_cli) { Bard::CLI::Provision.new(double("cli")) }
-
-  before do
-    allow(provision_cli).to receive(:config).and_return(config)
-    allow(provision_cli).to receive(:options).and_return({ steps: ["SSH", "User"] })
-  end
-
-  describe "STEPS constant" do
-    it "defines the provisioning steps" do
-      expect(Bard::CLI::Provision::STEPS).to include("SSH", "User", "Apt", "MySQL", "Deploy")
-      expect(Bard::CLI::Provision::STEPS).to be_a(Array)
-    end
-  end
-
-  describe "#provision" do
-    it "should run provision steps" do
-      expect(Bard::Provision).to receive(:const_get).with("SSH").and_return(double("ssh_step", call: true))
-      expect(Bard::Provision).to receive(:const_get).with("User").and_return(double("user_step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should use production ssh by default" do
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision
-    end
-
-    it "should accept custom ssh_url" do
-      custom_ssh = "root@newserver.com"
-      allow(Bard::Provision).to receive(:const_get).and_return(double("step", call: true))
-
-      provision_cli.provision(custom_ssh)
-    end
-  end
-end