danarchy_deploy 0.1.5 → 0.2.4

data/lib/danarchy_deploy/applicator/wordpress/wpcli_install.sh

@@ -0,0 +1,36 @@
+#!/bin/bash
+
+datetime=$(date +%F\ %T)
+log='/danarchy/deploy/wpcli_install.log'
+working_dir='/var/tmp'
+
+echo "WP-CLI Install: ${datetime}" > ${log}
+echo "Grabbing most recent wp-cli..." 2>&1 >> ${log}
+curl -sk https://raw.githubusercontent.com/wp-cli/builds/gh-pages/phar/wp-cli.phar -o ${working_dir}/wp-cli.phar 2>&1 >> ${log}
+
+success=''
+if [[ -f "${working_dir}/wp-cli.phar" ]]; then
+    echo "WP-CLI downloaded."
+    chmod +x ${working_dir}/wp-cli.phar
+
+    if [[ -x '/usr/bin/php' ]]; then
+	/usr/bin/php ${working_dir}/wp-cli.phar --info --allow-root && success='true'
+	mv -v ${working_dir}/wp-cli.phar /usr/local/bin/wp
+    else
+	echo 'PHP is not installed!'
+	rm -v ${working_dir}/wp-cli.phar
+	success='false'
+    fi
+else
+    echo "WP-CLI failed to download."
+    success='false'
+fi 2>&1 >> ${log}
+
+if [[ "${success}" = 'false' ]];then
+    echo -e "\nFailed to install WP-CLI!" 2>&1 >> ${log}
+    cat ${log} >&2
+    exit 1
+else
+    echo -e "WP-CLI successfully installed!" 2>&1 >> ${log}
+    cat ${log}
+fi

data/lib/danarchy_deploy/applicator/wordpress/wpconfig.rb

@@ -0,0 +1,49 @@
+module DanarchyDeploy
+  module Applicator
+    module WordPress
+      class WPConfig
+        def self.new(app, options)
+          puts "\n > Checking WordPress Configuration"
+          app = verify_generate_wp_salts(app, options)
+          wp_config(app, options)
+          app
+        end
+
+        private
+
+        def self.wp_config(app, options)
+          target = app[:path] + '/wp-config.php'
+          source = options[:deploy_dir] + '/templates/applications/wordpress/wp-config.php.erb'
+
+          templates = [{ target: app[:path] + '/wp-config.php',
+                         source: options[:deploy_dir] + '/templates/applications/wordpress/wp-config.php.erb',
+                         variables: { db_host:       app[:database][:db_host],
+                                      db_name:       app[:database][:db_name],
+                                      db_user:       app[:database][:db_user],
+                                      db_pass:       app[:database][:db_pass],
+                                      table_prefix:  app[:database][:table_prefix],
+                                      wp_keys_salts: app[:database][:salts],
+                         file_perms: { owner:        app[:username],
+                                       group:        app[:username],
+                                       mode:         '0644' } }
+                       }]
+
+          DanarchyDeploy::Templater.new(templates, options)
+        end
+
+        def self.verify_generate_wp_salts(app, options)
+          puts "\n   > Verifying WP authentication salts for #{app[:domain]}"
+          if app[:database][:salts]
+            puts '     |- Salts already exist! Using those.'
+          else
+            puts '     |+ Generating Auth Salts...'
+            uri = URI('https://api.wordpress.org/secret-key/1.1/salt/')
+            app[:database][:salts] = Net::HTTP.get(uri)
+          end
+
+          app
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/archiver.rb

@@ -1,3 +1,4 @@
+require_relative 'archiver/svn'
 
 module DanarchyDeploy
   class Archiver
@@ -8,18 +9,14 @@ module DanarchyDeploy
         abort("No target destination set for archive: #{archive[:source]}!") if !archive[:target]
 
         tmparchive = false
-        if !archive[:source]
+        if !archive[:source] && archive[:data]
           archive[:source] = options[:deploy_dir] + "/.tmp_archive_#{DateTime.now.strftime("%Y%m%d_%H%M%S")}"
           tmparchive = true
-        end
-
-        if archive[:data]
           data = DanarchyDeploy::Helpers.decode_base64(archive[:data])
           write_tmp_archive(archive[:source], data)
         end
-        
-        puts " > Extracting #{archive[:source]} to #{archive[:target]}"
 
+        puts " > Extracting #{archive[:source]} to #{archive[:target]}"
         if !File.exist?(archive[:source])
           puts "    ! Source file not found!: #{archive[:source]}"
           return false
@@ -32,10 +29,11 @@ module DanarchyDeploy
         if archive_result[:stderr]
           puts '   ! Archive extraction failed!'
           abort("STDERR:\n#{archive_result[:stderr]}")
-        else
+        elsif archive_result[:stdout]
           puts "   |+ Archive extracted: #{archive[:source]}\n"
         end
 
+        set_target_ownership(archive[:target], archive[:perms]) if archive[:perms]
         cleanup_source_archive(archive[:source]) if tmparchive
       end
     end
@@ -63,6 +61,10 @@ module DanarchyDeploy
       File.write(source, data)
     end
 
+    def self.set_target_ownership(target, perms)
+      FileUtils.chown_R(perms[:uid], perms[:gid], target)
+    end
+
     def self.cleanup_source_archive(source)
       File.delete(source)
     end

data/lib/danarchy_deploy/archiver/svn.rb

@@ -0,0 +1,17 @@
+
+module DanarchyDeploy
+  class Archiver
+    class Svn
+      def initialize(options)
+        @options = options
+      end
+
+      def co(repo, path)
+        puts "Checking out '#{repo}' to '#{path}'"
+        cmd = 'svn --non-interactive --trust-server-cert ' +
+              "co #{repo} #{path}"
+        DanarchyDeploy::Helpers.run_command(cmd, @options)
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/hash_deep_merge.rb

@@ -0,0 +1,9 @@
+class ::Hash
+  def deep_merge(second)
+    merger = proc do |key, v1, v2|
+      Hash === v1 && Hash === v2 ? v1.merge(v2, &merger) : Array === v1 && Array === v2 ? v1 | v2 : [:undefined, nil, :nil].include?(v2) ? v1 : v2
+    end
+
+    self.merge(second.to_h, &merger)
+  end
+end

data/lib/danarchy_deploy/helpers.rb

@@ -1,3 +1,4 @@
+require 'base64'
 require 'open3'
 
 module DanarchyDeploy
@@ -5,24 +6,55 @@ module DanarchyDeploy
     def self.run_command(command, options)
       pid, stdout, stderr = nil
       printf("%14s %0s\n", 'Running:', "#{command}")
-      Open3.popen3(command) do |i, o, e, t|
-        pid    = t.pid
-        (out, err) = o.read, e.read
-        stdout = !out.empty? ? out : nil
-        stderr = !err.empty? ? err : nil
-      end
 
-      if options[:ssh_verbose]
-        puts "------\nSTDOUT: ", stdout, '------' if stdout
-        puts "------\nSTDERR: ", stderr, '------' if stderr
+      if options[:pretend] && !options[:dev_gem]
+        pretend_run(command)
+      else
+        Open3.popen3(command) do |i, o, e, t|
+          pid    = t.pid
+          (out, err) = o.read, e.read
+          stdout = !out.empty? ? out : nil
+          stderr = !err.empty? ? err : nil
+        end
+
+        puts "------\nErrored at: #{caller_locations.first.label} Line: #{caller_locations.first.lineno}\nSTDERR: ", stderr, '------' if stderr
+        puts "------\nSTDOUT: ", stdout, '------' if stdout && options[:ssh_verbose]
       end
       
       { pid: pid, stdout: stdout, stderr: stderr }
     end
 
     def self.decode_base64(data)
-      require 'base64'
       Base64.decode64(data)
     end
+
+    def self.encode_base64(data)
+      Base64.encode64(data)
+    end
+
+    private
+    def self.pretend_run(command)
+      puts "\tFake run: #{command}"
+    end
+
+    def self.hash_except(hash, regex)
+      hash.dup.delete_if { |k,v| k.to_s =~ /#{regex}/ }
+    end
+
+    def self.hash_symbols_to_strings(hash)
+      new_hash = Hash.new
+      hash.each do |key, val|
+        if val.class == Hash
+          new_hash[key.to_s] = Hash.new
+          val.each do |k, v|
+            new_hash[key.to_s][k.to_s] = v
+          end
+        else
+          new_hash[key.to_s] = val
+        end
+      end
+
+      new_hash
+    end
   end
 end

data/lib/danarchy_deploy/services.rb

@@ -1,11 +1,16 @@
+require 'securerandom'
+require_relative 'services/init'
+require_relative 'services/mongodb'
+require_relative 'services/mysql'
 
 module DanarchyDeploy
-  class Services
+  module Services
     def self.new(deployment, options)
       puts "\n" + self.name
 
       deployment[:services].each do |service, params|
-        puts "Configuring service: #{service}"
+        next if service == :init
+        puts "\nConfiguring service: #{service}"
 
         if params[:archives] && !params[:archives].empty?
           puts "\n" + self.name
@@ -14,34 +19,16 @@ module DanarchyDeploy
         end
 
         if params[:templates] && !params[:templates].empty?
-          puts " > COnfiguring templates for #{service}"
+          puts " > Configuring templates for #{service}"
           DanarchyDeploy::Templater.new(params[:templates], options)
         end
-      end
-
-      deployment
-    end
 
-    private
-    def self.init(deployment, options)
-      puts "\n" + self.name
-
-      deployment[:services].each do |service, params|
-        next if !params[:init]
-        if options[:first_run] == false
-          puts "    ! Not a first-time run! Setting actions to 'reload'.\n\tUse --first-run to run actions: #{params[:init].join(' ,')}\n"
-          params[:init] = ['reload']
+        if %w[mysql mariadb].include?(service.to_s)
+          DanarchyDeploy::Services::MySQL.new(deployment[:os], params, options)
         end
 
-        params[:init].each do |action|
-          puts " > Taking action: #{action} on #{service}"
-          command = "systemctl #{action} #{service}"
-
-          if options[:pretend]
-            puts "    Fake run: #{command}\n"
-          else
-            DanarchyDeploy::Helpers.run_command(command, options)
-          end
+        if %[mongodb].include?(service.to_s)
+          DanarchyDeploy::Services::MongoDB.new(deployment[:os], params, options)
         end
       end
 

data/lib/danarchy_deploy/services/init.rb

@@ -0,0 +1,52 @@
+require_relative 'init/openrc'
+require_relative 'init/systemd'
+
+module DanarchyDeploy
+  module Services
+    class Init
+      def self.new(deployment, options)
+        puts "\n" + self.name
+
+        deployment[:services].each do |service, params|
+          next if ! params[:init]
+          orig_actions = params[:init]
+          puts "\n > Init actions for #{service}: #{params[:init].join(', ')}"
+          params[:init].each do |action|
+            puts "    |+ Taking action: #{action} on #{service}"
+            if options[:pretend]
+              puts "       Fake run: #{action} #{service}"
+            else
+              init_manager(deployment[:os], service, action, options)
+            end
+          end
+
+          params[:init] = orig_actions
+        end
+
+        deployment
+      end
+
+      def self.init_manager(os, service, action, options)
+        init = if os == 'gentoo'
+                 DanarchyDeploy::Services::Init::Openrc.new(service, options)
+               else
+                 DanarchyDeploy::Services::Init::Systemd.new(service, options)
+               end
+
+        init_result = init.send(action)
+
+        if init_result[:stderr]
+          if init_result[:stderr].include?('unknown function')
+            puts "       ! Action: #{action} not available for service: #{service}.\n" +
+                 "          ! A restart may be needed! Otherwise, remove this action from the deployment.\n" +
+                 "          ! Not taking any action here.\n"
+          else
+            abort("       ! Action: #{service} #{action} failed!")
+          end
+        else
+          puts "       |+ Action: #{service} #{action} succeeded."
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/services/init/openrc.rb

@@ -0,0 +1,72 @@
+
+module DanarchyDeploy
+  module Services
+    class Init
+      class Openrc
+        def initialize(service, options)
+          @service = service
+          @options = options
+        end
+
+        def status
+          cmd = "rc-service #{@service} status"
+          return { stdout: "Fake run: started", stderr: nil } if @options[:pretend]
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def start
+          cmd = "rc-service #{@service} start"
+          status = self.status
+
+          if status[:stdout].include?('started')
+            return status
+          else
+            DanarchyDeploy::Helpers.run_command(cmd, @options)
+          end
+        end
+
+        def stop
+          cmd = "rc-service #{@service} stop"
+          status = self.status
+
+          if status[:stdout].include?('stopped')
+            return status
+          else
+            DanarchyDeploy::Helpers.run_command(cmd, @options)
+          end
+        end
+
+        def reload
+          status = self.status
+
+          cmd = if status[:stderr]
+                  # status[:stdout].include?('running')
+                  # This used to check for status "running"; and previously "started".
+                  # Too specific so I've disabled it since I don't remember what this exception was for, originally.
+                  puts "        |! Service: #{@service} is not running. Starting it up instead."
+                  "rc-service #{@service} start"
+                else
+                  "rc-service #{@service} reload"
+                end
+
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def restart
+          cmd = "rc-service #{@service} restart"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def enable
+          cmd = "rc-update add #{@service} default"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def disable
+          cmd = "rc-update del #{@service} default"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/services/init/systemd.rb

@@ -0,0 +1,69 @@
+
+module DanarchyDeploy
+  module Services
+    class Init
+      class Systemd
+        def initialize(service, options)
+          @service = service
+          @options = options
+        end
+
+        def status
+          cmd = "systemctl show #{@service} --no-page"
+          # return { stdout: "Fake run: started", stderr: nil } if @options[:pretend]
+          status = DanarchyDeploy::Helpers.run_command(cmd, @options)
+          status[:stdout].split(/\n/).grep(/ActiveState/).first.split('=').last
+        end
+
+        def start
+          cmd = "systemctl start #{@service}"
+          status = self.status
+
+          if status == 'active'
+            return status
+          else
+            DanarchyDeploy::Helpers.run_command(cmd, @options)
+          end
+        end
+
+        def stop
+          cmd = "systemctl #{@service} stop"
+          status = self.status
+
+          if status == 'inactive'
+            return status
+          else
+            DanarchyDeploy::Helpers.run_command(cmd, @options)
+          end
+        end
+
+        def reload
+          status = self.status
+
+          cmd = if status == 'inactive'
+                  "systemctl start #{@service}"
+                else
+                  "systemctl reload #{@service}"
+                end
+
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def restart
+          cmd = "systemctl restart #{@service}"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def enable
+          cmd = "systemctl enable #{@service}"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def disable
+          cmd = "systemctl enable #{@service}"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+      end
+    end
+  end
+end