escualo 1.0.3 → 2.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: c809f160a9a7a6ada7701ad6ff2caa6aebe94738
-  data.tar.gz: 2782155da8b03c01acf3f79291b406f62cfcb92c
+  metadata.gz: 4a1b1332770052855fe4cf7dd3fc315d59c7013d
+  data.tar.gz: c1ed05104e4191224af4cba5ebd1471d8be6f188
 SHA512:
-  metadata.gz: 9b613bec310b5a1e7f723a17c861b845f98ee18e8b2ca721df7cb214a5972f642559656fb6102cfcc2eb867e5627082919a5140e1109f5f82f6bb4491c78053e
-  data.tar.gz: 5303602c1b75568956a8883607118d23596cbe2192c39e2e0d876d0fb6828cc87a5a231bad5bc8850ac4e0e1376b3ab77f084df0d7d832e633666dc57e8d6854
+  metadata.gz: 99fb17f7ccea1a403c6f4622db1ff626bb5edb416ddd2a99691323c15440df7957f616c303a1d46ef78621595bccdf119a8a4af6d8a97f63d0002139cd87633c
+  data.tar.gz: a65eee75b9d738447f68c06decf20c465c4fc7480a1830a731262d1d90356364b1ce98fffbfe2cfb2a61c7819a59261c3f244f7c033a2beba8960e4f54558582

data/bin/escualo

@@ -10,23 +10,21 @@ program :description, 'escualo provisioning tool implementation for ruby'
 
 require_relative '../lib/command'
 
-def step(name, &block)
-  say name
+def step(name, options=struct, &block)
+  say name unless options.dockerized
   block.call
 end
 
-def do_unless(done, done_message, options)
-  if !options.force && done
+def exit_if(done_message, options)
+  if !options.force && !options.dockerized && yield
     say "Nothing to do. #{done_message}"
     say 'Use --force to proceed it anyway'
-  else
-    yield
+    exit
   end
 end
 
 require_relative '../lib/commands/globals'
 
-require_relative '../lib/commands/base'
 require_relative '../lib/commands/bootstrap'
 require_relative '../lib/commands/deploy'
 require_relative '../lib/commands/script'

data/lib/command.rb

@@ -1,12 +1,11 @@
 class Commander::Command
-  def ssh_action(&block)
+  def session_action(force_local=false, &block)
     action do |args, options|
-      if $ssh_remote
-        say "Connecting to remote host #{$hostname}... " if options.verbose
-      else
-        say 'Running commands locally... ' if options.verbose
-      end
-      Net::SSH.with_session(ssh_session_options) { |ssh| block.call(args, options, ssh) }
+      Escualo::Session.within(options, force_local) { |session| block.call(args, options, session) }
     end
   end
+
+  def local_session_action(&block)
+    session_action true, &block
+  end
 end

data/lib/commands/artifact.rb

@@ -1,8 +1,8 @@
 command 'artifact list' do |c|
   c.syntax = 'escualo artifact list'
   c.description = 'Lists artifacts on host'
-  c.ssh_action do |args, options, ssh|
-    Escualo::Artifact.list(ssh).each do |artifact|
+  c.session_action do |args, options, session|
+    Escualo::Artifact.list(session).each do |artifact|
       say artifact
     end
   end
@@ -11,65 +11,43 @@ end
 command 'artifact destroy' do |c|
   c.syntax = 'escualo artifact destroy <NAME>'
   c.description = 'Destroys an artifact on host'
-  c.ssh_action do |args, options, ssh|
-    name = args.first
-
-    Escualo::Artifact.destroy(ssh, name)
-
-    if !Escualo::Artifact.present? ssh, name
-      say "#{name} destroyed successfully"
-    else
-      abort "Could not destroy artifact #{name}"
-    end
-  end
-end
-
-def check_created(kind, name)
-  if Escualo::Artifact.present?(ssh, name)
-    say "#{kind.titleize} #{name} created successfully"
-    say "Now you can deploy this #{kind}"
-  else
-    abort "Failed to create artifact #{name}"
+  c.session_action do |args, options, session|
+    Escualo::Artifact.destroy(session, args.first)
   end
 end
 
 command 'artifact create service' do |c|
   c.syntax = 'escualo artifact create service <NAME> <PORT>'
   c.description = 'Setup a micro-service deployment'
-  c.option '-f', '--force', TrueClass, 'Force creation even if already done'
 
-  c.ssh_action do |args, options, ssh|
+  c.session_action do |args, options, session|
     name = args.first
     port = args.second
 
-    do_unless Escualo::Artifact.present?(ssh, name),
-              "Service #{name} already created",
-              options do
-      launch_command = "exec bundle exec rackup -o 0.0.0.0 -p #{port} > rack.log"
-      install_command='bundle install --without development test'
-
-      step 'Creating init scripts...' do
-        Escualo::Artifact.create_scripts_dir ssh, name
-        Escualo::Artifact.create_init_script ssh,
-                                             name: name,
-                                             service: true,
-                                             install_command: install_command
-        Escualo::Artifact.create_codechange_script ssh, name
-      end
-
-      step 'Configuring upstart...' do
-        Escualo::Artifact.configure_upstart ssh, name: name, launch_command: launch_command
-      end
-
-      step 'Configuring monit...' do
-        Escualo::Artifact.configure_monit ssh, name: name, port: port
-      end
-
-      step 'Creating push infrastructure' do
-        Escualo::Artifact.create_push_infra ssh, name: name, service: true
-      end
-
-      check_created 'service', name
+    exit_if("Service #{name} already created", options) { Escualo::Artifact.present?(session, name) }
+
+    launch_command = "exec bundle exec rackup -o 0.0.0.0 -p #{port} > rack.log"
+    install_command='bundle install --without development test'
+
+    step 'Creating init scripts...', options do
+      Escualo::Artifact.create_scripts_dir session, name
+      Escualo::Artifact.create_init_script session,
+                                           name: name,
+                                           service: true,
+                                           install_command: install_command
+      Escualo::Artifact.create_codechange_script session, name
+    end
+
+    step 'Configuring upstart...', options do
+      Escualo::Artifact.configure_upstart session, name: name, launch_command: launch_command
+    end
+
+    step 'Configuring monit...', options do
+      Escualo::Artifact.configure_monit session, name: name, port: port
+    end
+
+    step 'Creating push infrastructure', options do
+      Escualo::Artifact.create_push_infra session, name: name, service: true
     end
   end
 end
@@ -77,23 +55,18 @@ end
 command 'artifact create site' do |c|
   c.syntax = 'escualo artifact create site <NAME>'
   c.description = 'Setup an static site deployment'
-  c.option '-f', '--force', TrueClass, 'Force creation even if already done'
 
-  c.ssh_action do |args, options, ssh|
+  c.session_action do |args, options, session|
     name = args.first
+    exit_if("Site #{name} already created", options) { Escualo::Artifact.present?(session, name) }
 
-    do_unless Escualo::Artifact.present?(ssh, name),
-              "Site #{name} already created",
-              options do
-      step 'Creating init scripts...' do
-        Escualo::Artifact.create_scripts_dir ssh, name
-        Escualo::Artifact.create_init_script ssh, name: name, static: true
-      end
-
-      step 'Creating push infrastructure' do
-        Escualo::Artifact.create_push_infra ssh, name: name, static: true
-      end
-      check_created 'site', name
+    step 'Creating init scripts...', options do
+      Escualo::Artifact.create_scripts_dir session, name
+      Escualo::Artifact.create_init_script session, name: name, static: true
+    end
+
+    step 'Creating push infrastructure', options do
+      Escualo::Artifact.create_push_infra session, name: name, static: true
     end
   end
 end
@@ -101,23 +74,18 @@ end
 command 'artifact create executable' do |c|
   c.syntax = 'escualo artifact create executable <NAME>'
   c.description = 'Setup an executable command deployment'
-  c.option '-f', '--force', TrueClass, 'Force creation even if already done'
 
-  c.ssh_action do |args, options, ssh|
+  c.session_action do |args, options, session|
     name = args.first
 
-    do_unless Escualo::Artifact.present?(ssh, name),
-              "Executable #{name} already created",
-              options do
-      step 'Creating init scripts...' do
-        Escualo::Artifact.create_scripts_dir ssh, name
-        Escualo::Artifact.create_init_script ssh, name: name, executable: true
-      end
-
-      step 'Creating push infrastructure' do
-        Escualo::Artifact.create_push_infra ssh, name: name, executable: true
-      end
-      check_created 'executable', name
+    exit_if("Executable #{name} already created", options) { Escualo::Artifact.present?(session, name) }
+    step 'Creating init scripts...', options do
+      Escualo::Artifact.create_scripts_dir session, name
+      Escualo::Artifact.create_init_script session, name: name, executable: true
+    end
+
+    step 'Creating push infrastructure', options do
+      Escualo::Artifact.create_push_infra session, name: name, executable: true
     end
   end
 end

data/lib/commands/bootstrap.rb

@@ -4,40 +4,45 @@ command 'bootstrap' do |c|
   c.option '--swap', TrueClass, 'Setup swap?'
   c.option '--env ENVIRONMENT', String, 'Environment. Valid options are development and production. default is production'
   c.option '--with-rbenv', TrueClass, 'Use rbenv instead of native ruby installation'
-  c.option '-f', '--force', TrueClass, 'Force bootstrap even if already done?'
 
-  c.ssh_action do |_args, options, ssh|
+  c.session_action do |_args, options, session|
     options.default env: 'production'
 
-    do_unless Escualo::Bootstrap.check(ssh), 'This host has already been bootstrapped', options do
+    exit_if('This host has already been bootstrapped', options) do
+      Escualo::Env.present?(session, :ESCUALO_BASE_VERSION) && Escualo::Gems.installed?(session)
+    end
 
-      step 'Enabling swap...' do
-        Escualo::Bootstrap.enable_swap ssh
-      end if options.swap
+    step 'Configuring variables...', options do
+      Escualo::Env.setup session
+      Escualo::Env.set_builtins session, options
+    end
 
-      step 'Configuring variables...' do
-        Escualo::Env.setup ssh
-        Escualo::Env.set_locale ssh, options
-        Escualo::Env.set_builtins ssh, options
-      end
+    step 'Configuring locales...', options do
+      Escualo::Base.configure_locales session
+    end
 
-      step 'Installing Ruby...' do
-        Escualo::Bootstrap.install_ruby ssh, options
-      end
+    step 'Installing base software', options do
+      Escualo::Base.install session
+    end
 
-      step 'Installing gems...' do
-        Escualo::Gems.install ssh, options
-      end
+    step 'Adding package repositories', options do
+      Escualo::Base.add_repositories session
+    end
 
-      step 'Setup artifact directories...' do
-        Escualo::Artifact.setup ssh
-      end
+    step 'Enabling swap...', options do
+      Escualo::Base.enable_swap session
+    end if options.swap
+
+    step 'Installing Ruby...', options do
+      Escualo::Ruby.install session, options
+    end
+
+    step 'Installing gems...', options do
+      Escualo::Gems.install session
+    end
 
-      if Escualo::Bootstrap.check ssh
-        say 'Host bootstrapped successfully '
-      else
-        abort 'bootstrapping failed'
-      end
+    step 'Setup artifact directories...', options do
+      Escualo::Artifact.setup session
     end
   end
 end

data/lib/commands/deploy.rb

@@ -2,15 +2,17 @@ command 'deploy' do |c|
   c.syntax = 'escualo deploy <name> <repo>'
   c.description = 'Deploys repository to the given executable, service or site'
   c.option '--tag GIT_TAG', String, 'Github tag to deploy'
-  c.action do |args, options|
+  c.local_session_action do |args, options, session|
+    session_options = Escualo::Session.parse_session_options(options)
+
     Dir.mktmpdir do |dir|
-      step 'Cloning repository...' do
-        Escualo::Remote.clone dir, args.second, options
-        Escualo::Remote.attach dir, args.first
+      step 'Cloning repository...', options do
+        Escualo::Remote.clone session, dir, args.second, options
+        Escualo::Remote.attach session, dir, args.first, session_options
       end
 
-      step 'Pushing to remote...' do
-        Escualo::Remote.push dir
+      step 'Pushing to remote...', options do
+        Escualo::Remote.push session, dir
       end
     end
   end

data/lib/commands/env.rb

@@ -1,12 +1,11 @@
 command 'env list' do |c|
   c.syntax = 'escualo env list'
   c.description = 'List escualo variables on host'
-  c.ssh_action do |args, options, ssh|
-    say Escualo::Env.list ssh
+  c.session_action do |_args, _options, session|
+    say Escualo::Env.list session
   end
 end
 
-
 def parse_args_variables(args)
   args.map { |it| it.split('=') }.to_h
 end
@@ -14,23 +13,27 @@ end
 command 'env set' do |c|
   c.syntax = 'escualo env set <NAME>=<VALUE> [<NAME>=<VALUE>,...<NAME>=<VALUE>]'
   c.description = 'Sets one or more escualo variables on host'
-  c.ssh_action do |args, options, ssh|
-    Escualo::Env.set ssh, parse_args_variables(args)
+  c.session_action do |args, _options, session|
+    Escualo::Env.set session, parse_args_variables(args)
   end
 end
 
 command 'env unset' do |c|
   c.syntax = 'escualo env unset <NAME> [<NAME>,...<NAME>]'
   c.description = 'Unset escualo variables on host'
-  c.ssh_action do |args, options, ssh|
-    Escualo::Env.unset ssh, args
+  c.session_action do |args, _options, session|
+    Escualo::Env.unset session, args
   end
 end
 
 command 'env clean' do |c|
   c.syntax = 'escualo env clean'
+  c.option '--env ENVIRONMENT', String, 'Environment. Valid options are development and production. default is production'
+
   c.description = 'Unset all escualo variables on host'
-  c.ssh_action do |args, options, ssh|
-    Escualo::Env.clean ssh, options
+  c.session_action do |_args, options, session|
+    options.default env: 'production'
+
+    Escualo::Env.clean session, options
   end
 end

data/lib/commands/globals.rb

@@ -1,41 +1,12 @@
-$hostname = 'localhost'
-$username = 'root'
-$ssh_options = {}
-$ssh_remote = false
+global_option '-h', '--hostname HOSTNAME', String, 'The host to connect. Defaults to "localhost"'
+global_option '-u', '--username USERNAME', String, 'The username to connect. Defaults to "root"'
 
-global_option '-h', '--hostname HOSTNAME', String, 'The host to connect. Defaults to "localhost"' do |hostname|
-  $hostname = hostname
-  $ssh_remote = true
-end
+global_option '-i', '--ssh-key PRIVATE_KEY', String, 'An optional private key'
+global_option '--ssh-port PORT', String, 'The ssh port to connect. Defaults to 22'
+global_option '--ssh-password PASSWORD', String, 'An optional remote password'
 
-global_option '-u', '--username USERNAME', String, 'The username to connect. Defaults to "root"' do |username|
-  $username = username
-  $ssh_remote = true
-end
-
-global_option '--password PASSWORD', String, 'An optional remote password' do |password|
-  $password = password
-  $ssh_options[:password] = password
-  $ssh_remote = true
-end
-
-global_option '-i', '--ssh-key PRIVATE_KEY', String, 'An optional private key' do |private_key|
-  $ssh_key = private_key
-  $ssh_options[:keys] = [private_key]
-  $ssh_remote = true
-end
-
-global_option '--ssh-port PORT', String, 'The ssh port to connect. Defaults to 22' do |port|
-  $ssh_port = port
-  $ssh_options[:port] = port
-  $ssh_remote = true
-end
+global_option '--dockerized', TrueClass, 'Generate a docker script instead of running the commands'
 
 global_option '--verbose', TrueClass, 'Dumps extra output'
 
-def ssh_session_options
-  $ssh_options.merge(
-      username: $username,
-      hostname: $hostname,
-      local: !$ssh_remote).compact
-end
+global_option '-f', '--force', TrueClass, 'Force command run'

data/lib/commands/plugin.rb

@@ -6,31 +6,23 @@ command 'plugin install' do |c|
   c.option '--rabbit-admin-password PASSWORD', String, 'rabbitmq admin password, only for rabbit plugin'
 
   c.option '--pg-version VERSION', String, 'PostgreSQL major and minor version. Default is 9.3, only for postgre plugin'
+  c.option '--pg-username USERNAME', String, 'PostgreSQL username'
+  c.option '--pg-password PASSWORD', String, 'PostgreSQL password'
 
   c.option '--monit-version VERSION', String, 'Monit version. Default is 5.16'
   c.option '--monit-password PASSWORD', String, 'Monit password. Required with monit plugin'
 
-  c.option '-f', '--force', TrueClass, 'Force reinstalling even if already done'
-  c.ssh_action do |args, options, ssh|
+  c.session_action do |args, options, session|
     options.default pg_version: '9.3',
                     monit_version: '5.16'
 
     plugin = args.first
-    say "Installing #{plugin}"
-
     installer = Escualo::Plugin.load plugin
 
-    do_unless installer.check(ssh, options),
-              "Plugin #{plugin} is already installed",
-              options do
-
-      step "Installing plugin #{plugin}" do
-        if Escualo::Plugin.run_and_check installer, ssh, options
-          say 'Installed successfully!'
-        else
-          abort 'Installation of plugin failed'
-        end
-      end
+    exit_if("Plugin #{plugin} is already installed", options) { installer.installed?(session, options) }
+
+    step "Installing plugin #{plugin}", options do
+      installer.run session, options
     end
   end
 end
@@ -39,11 +31,9 @@ command 'plugin list' do |c|
   c.syntax = 'escualo plugin list'
   c.description = 'List installed plugins on host'
 
-  c.ssh_action do |_args, _options, ssh|
+  c.session_action do |_args, _options, session|
     Escualo::Plugin::PLUGINS.each do |plugin|
-      if Escualo::Plugin.load(plugin).check ssh
-        say plugin
-      end
+      say plugin if Escualo::Plugin.load(plugin).installed? session
     end
   end
 end

data/lib/commands/rake.rb

@@ -1,13 +1,11 @@
 command 'rake' do |c|
   c.syntax = 'escualo rake <SERVICE_NAME> <TASK>'
   c.description = 'Run rake task on host'
-  c.ssh_action do |args, options, ssh|
+  c.session_action do |args, _options, session|
     name = args.first
     task = args.second
-    ssh.shell.perform! %Q{
-      cd /var/www/#{name}
-      rake #{task}
-    }, options
+
+    session.tell! "cd /var/www/#{name} && rake #{task}"
   end
 end
 

data/lib/commands/remote.rb

@@ -3,10 +3,11 @@ command 'remote attach' do |c|
   c.description = "Adds the given artifact to current's repository"
   c.option '--repo-path PATH', String, 'Sets the git dir'
 
-  c.action do |args, options|
+  c.local_session_action do |args, options, session|
     options.default repo_path: Dir.pwd
+    session_options = Escualo::Session.parse_session_options options
 
-    Escualo::Remote.attach options.repo_path, args.first
+    Escualo::Remote.attach session, options.repo_path, args.first, session_options
   end
 end
 
@@ -15,10 +16,10 @@ command 'remote show' do |c|
   c.description = "Show attached artifacts to current's repository"
   c.option '--repo-path PATH', String, 'Sets the git dir'
 
-  c.action do |_args, options|
+  c.local_session_action do |_args, options, session|
     options.default repo_path: Dir.pwd
 
-    Escualo::Remote.remotes(options.repo_path).each { |it| say it }
+    Escualo::Remote.remotes(session, options.repo_path).each { |it| say it }
   end
 end
 
@@ -26,7 +27,7 @@ command 'remote push' do |c|
   c.syntax = 'escualo remote push'
   c.description = 'Pushes artifact at current repository'
   c.action do |_args, _options|
-    Escualo::Remote.push Dir.pwd
+    Escualo::Remote.push session, Dir.pwd
   end
 end
 

data/lib/commands/script.rb

@@ -2,38 +2,19 @@ command 'script' do |c|
   c.syntax = 'escualo script <FILE>'
   c.description = 'Runs a escualo configuration'
   c.option '--dockerized', TrueClass, 'Create a Dockerfile instead of running commands'
+  c.option '--write-dockerfile', TrueClass, 'Write a complete Dockerfile instead of writing to stdout. Default is false'
+  c.option '--dockerfile PATH', String, 'Destination Dockerfile. Default is `Dockerfile`'
   c.option '--development', TrueClass, 'Use local escualo gemspec instead of fetching from internet'
   c.option '--base-image BASE_IMAGE', String, 'Default base image. Only for dockerized runs'
 
   c.action do |args, options|
-    options.default base_image: 'ubuntu'
-
-    if options.dockerized
-      mode = Escualo::Script::Dockerized.new
-    else
-      mode = Escualo::Script::Standard.new
-    end
-
-    mode.start! options
-
+    options.default base_image: 'ubuntu',
+                    dockerfile: 'Dockerfile'
     file = YAML.load_file args.first
-
-    local_ssh = Net::SSH::Connection::LocalSession.new
     delegated_options = Escualo::Script.delegated_options options
 
-    step 'Running local commands...' do
-      mode.run_commands_for! file['local'], delegated_options, local_ssh, options
+    Escualo::Session.within(options, true) do |session|
+      Escualo::Script.run!(session, $PROGRAM_NAME, file, delegated_options)
     end
-    step 'Running remote commands...' do
-      Net::SSH.with_session(ssh_session_options) do |ssh|
-        mode.run_commands_for! file['remote'], ssh, options
-      end
-    end
-
-    step 'Running deploy commands...' do
-      mode.run_commands_for! file['deploy'], delegated_options, local_ssh, options
-    end
-
-    mode.finish!
   end
 end

data/lib/commands/upload.rb

@@ -1,7 +1,7 @@
 command 'upload' do |c|
   c.syntax = 'escualo upload <FILE> <DESTINATION>'
   c.description = 'Upload file to host'
-  c.ssh_action do |args, options, ssh|
-    ssh.scp.upload! args.first, args.second
+  c.session_action do |args, _options, session|
+    session.upload! args.first, args.second
   end
 end

data/lib/escualo/apt_get.rb

@@ -0,0 +1,10 @@
+module Escualo::AptGet
+  def self.install(session, packages_string, options={})
+    session.tell_all! update_command(options),
+                      "apt-get install -y --force-yes #{packages_string}"
+  end
+
+  def self.update_command(options)
+    'apt-get update' if options[:update]
+  end
+end