danarchy_deploy 0.1.2 → 0.2.1

data/lib/danarchy_deploy/applicator.rb

@@ -0,0 +1,39 @@
+require_relative 'applicator/wordpress'
+require_relative 'applicator/nginx'
+require_relative 'applicator/phpfpm'
+require_relative 'applicator/ssl'
+
+module DanarchyDeploy
+  module Applicator
+    def self.new(os, user, options)
+      puts "\n" + self.name
+
+      user[:applications].each do |domain, app|
+        app[:domain] = domain.to_s
+        app[:username] = user[:username]
+        app[:path] = app[:path] ? app[:path] : user[:home] + '/' + app[:domain]
+
+        Dir.exist?(app[:path]) || FileUtils.mkdir_p(app[:path], mode: 0755)
+        FileUtils.chown_R(user[:username], user[:username], app[:path])
+
+        if app[:archives] && options[:first_run]
+          puts "\n > Deploying archives for #{domain}"
+          perms = { uid: user[:uid], gid: user[:gid] }
+          app[:archives].map{|a| a[:perms] = perms }
+          puts "\n   |> Applying user's ownership to archives: #{perms}"
+          DanarchyDeploy::Archiver.new(app[:archives], options)
+        end
+
+        app = DanarchyDeploy::Applicator::PHPFPM.new(app, options)    if app[:phpfpm]
+        app = DanarchyDeploy::Applicator::Nginx.new(app, options)     if app[:nginx]
+        app = DanarchyDeploy::Applicator::WordPress.new(app, options) if app[:app] == 'wordpress'
+        app = DanarchyDeploy::Applicator::Redmine.new(app, options)   if app[:app] == 'redmine'
+
+        app.delete_if { |k, v| [:username, :domain].include? k }
+        user[:applications][domain] = app
+      end
+
+      user
+    end
+  end
+end

data/lib/danarchy_deploy/applicator/nginx.rb

@@ -0,0 +1,86 @@
+
+module DanarchyDeploy
+  module Applicator
+    class Nginx
+      def self.new(app, options)
+        puts "\n" + self.name
+        puts "\n > Checking Nginx configuration for #{app[:username]}."
+
+        app = generate_paths(app, options)
+        if app[:nginx] == 'enabled'
+          enable_nginx(app, options)
+        elsif app[:nginx] == 'disabled'
+          disable_nginx(app, options)
+        end
+
+        app
+      end
+
+      def self.generate_paths(app, options)
+        nginx_config = Dir['/etc/nginx/**/nginx.conf'].last
+        sites_enabled = nil
+
+        if nginx_config.nil? && options[:pretend]
+          sites_enabled = '/etc/nginx/sites_enabled/'
+          puts "   - Fake run: Testing deployment using #{sites_enabled}"
+        elsif nginx_config.nil? && !options[:pretend]
+          abort("\n  ! ERROR: Could not establish nginx.conf location!")
+        else
+          nginx_config = File.readlines(nginx_config)
+          sites_enabled = nginx_config.grep(/include/).last.gsub(/\s+include |\*.conf;/, '').chomp.gsub(/\*;/, '')
+        end
+
+        app[:domaincfg] = app[:domaincfg] ?
+                              app[:domaincfg] :
+                              "/home/#{app[:username]}/nginx/sites-enabled/#{app[:domain]}.conf"
+        # app[:domaincfg] = "/home/#{app[:username]}/nginx/sites-enabled/#{app[:domain]}.conf" #sites_enabled + "#{app[:domain]}.conf"
+        app[:log_dir] = app[:log_dir] ?
+                          app[:log_dir] :
+                          "/home/#{app[:username]}/nginx/logs/#{app[:domain]}"
+        app
+      end
+
+      def self.enable_nginx(app, options)
+        if !options[:pretend]
+          puts "\n   |+ Enabling Nginx for '#{app[:domain]}'."
+          FileUtils.mkdir_p([File.dirname(app[:domaincfg]), app[:log_dir]])
+          FileUtils.chown_R(app[:username], app[:username], "/home/#{app[:username]}/nginx")
+          DanarchyDeploy::Users.add_to_group({username: 'nginx', groups: [app[:username]]}, options)
+        end
+
+        source = options[:deploy_dir] + '/templates/applications/nginx/domain.conf.erb'
+        template = { target: app[:domaincfg],
+                     source: source,
+                     variables: { username: app[:username],
+                                  domain:   app[:domain] },
+                     dir_perms: { owner: app[:username],
+                                  group: app[:username],
+                                  mode: '0755' },
+                     file_perms: { owner: app[:username],
+                                   group: app[:username],
+                                   mode: '0644' } }
+
+        # if app[:ssl]
+        #   if app[:ssl][:type] == 'letsencrypt'
+        #     DanarchyDeploy::Applicator::SSL::LetsEncrypt.new(template, options)
+        #   end
+        # end
+
+        templates = [template]
+        DanarchyDeploy::Templater.new(templates, options)
+      end
+
+      def self.disable_nginx(app, options)
+        if options[:pretend]
+          puts "   - Fake run: Remove #{app[:domaincfg]}"
+        else
+          puts "\n   ! Disabling Nginx for '#{app[:domain]}'."
+          if File.exist?(app[:domaincfg])
+            File.delete(app[:domaincfg])
+            puts "    |_ Removed: #{app[:domaincfg]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/applicator/phpfpm.rb

@@ -0,0 +1,84 @@
+
+module DanarchyDeploy
+  module Applicator
+    class PHPFPM
+      def self.new(app, options)
+        puts "\n" + self.name
+        puts "\n > Checking #{app[:username]}'s PHP-FPM config."
+
+        app = generate_paths(app, options)
+        if app[:phpfpm] == 'enabled'
+          enable_phpfpm(app, options)
+        elsif app[:phpfpm] == 'disabled'
+          disable_phpfpm(app, options)
+        end
+
+        app
+      end
+
+      def self.generate_paths(app, options)
+        phpfpm_config = Dir['/etc/**/php-fpm.conf'].last
+        sites_enabled = nil
+
+        if phpfpm_config.nil? && options[:pretend]
+          sites_enabled = '/etc/php/fpm-pretend/sites_enabled/'
+          puts "   - Fake run: Testing deployment using #{sites_enabled}"
+        elsif phpfpm_config.nil? && !options[:pretend]
+          abort("\n  ! ERROR: Could not establish php-fpm.conf location!")
+        else
+          puts "   |+ Found php-fpm.conf at: #{phpfpm_config}."
+          phpfpm_config = File.readlines(phpfpm_config)
+          sites_enabled = phpfpm_config.grep(/^include/).last.gsub(/(^.*=|\*$|\*.conf)/, '').chomp        
+        end
+
+        app[:phpcfg] = app[:phpcfg] ?
+                         app[:phpcfg] :
+                         "/home/#{app[:username]}/php-fpm/sites-enabled/#{app[:domain]}.conf"
+        # app[:phpcfg] = sites_enabled + "#{app[:domain].gsub('.','_')}.conf"
+        app
+      end
+
+      def self.enable_phpfpm(app, options)
+        tmpdir = "/home/#{app[:username]}/tmp"
+
+        if !options[:pretend]
+          puts "\n  |+ Enabling PHP-FPM for '#{app[:username]}'."
+          FileUtils.mkdir_p(File.dirname(app[:phpcfg]))
+          FileUtils.mkdir_p(tmpdir, mode: 1750)
+          FileUtils.chown(app[:username], app[:username], tmpdir)
+        end
+
+        pool = app[:domain].gsub('.','_')
+        web_user = 'nginx'  if app[:nginx]
+        web_user = 'apache' if app[:apache]
+        source = options[:deploy_dir] + '/templates/applications/php/phpfpm.conf.erb'
+        templates = [{ target: app[:phpcfg],
+                       source: source,
+                       variables: { pool: pool,
+                                    username: app[:username],
+                                    web_user: web_user,
+                                    tmp:      tmpdir },
+                       dir_perms: { owner: 'root',
+                                    group: 'root',
+                                    mode: '0755' },
+                       file_perms: { owner: 'root',
+                                     group: 'root',
+                                     mode: '0644' } }]
+
+        DanarchyDeploy::Templater.new(templates, options)
+      end
+
+      def self.disable_phpfpm(app, options)
+        if options[:pretend]
+          puts "   - Fake run: Remove #{app[:user_phpcfg]}"
+        else
+          puts "\n  ! Disabling PHP-FPM for '#{app[:username]}'."
+          if File.exist?(app[:phpcfg])
+            File.delete(app[:phpcfg]) 
+            puts "    |_ Removed: #{app[:phpcfg]}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/applicator/redmine.rb

@@ -0,0 +1,40 @@
+
+module DanarchyDeploy
+  module Applicator
+    module Redmine
+      def self.new(app, options)
+        puts "\n" + self.name
+        puts " > Checking on Redmine installation at #{app[:path]}"
+
+        repo = 'https://svn.redmine.org/redmine/branches/' + app[:version]
+      end
+
+      private
+      def self.cmd_prefix(app)
+        
+      end
+
+      def self.redmine_version(app)
+        version = []
+        version_rb = File.readlines(app[:path] + '/lib/redmine/version.rb')
+        version_rb.grep(/(MAJOR|MINOR|TINY)\s+=/).each do |v|
+          v = v.chomp.gsub!(/\s+/, '')
+          version.push(v.split(/=/).last)
+        end
+
+        version.join('.')
+      end
+
+      def self.database_yml(app)
+        dbs = app[:database]
+        dbs.each do |db, values|
+          values[:adapter] = values[:adapter] ? values[:adapter] : 'mysql2'
+          values[:encoding] = values[:encoding] ? values[:encoding] : 'utf8'
+        end
+
+        db_yml = app[:path] + '/config/database.yml'
+        File.write(db_yml, dbs.to_yaml)
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/applicator/ssl.rb

@@ -0,0 +1,14 @@
+
+module DanarchyDeploy
+  module Applicator
+    module SSL
+      class SelfSigned
+
+      end
+
+      class LetsEncrypt
+        # DateTime.now > DateTime.parse(cert.grep(/Not After/).first.split(' : ').last) - 7
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/applicator/wordpress.rb

@@ -0,0 +1,146 @@
+require 'net/http'
+require_relative 'wordpress/wpcli'
+require_relative 'wordpress/wpconfig'
+
+module DanarchyDeploy
+  module Applicator
+    module WordPress
+      def self.new(app, options)
+        puts "\n" + self.name
+        puts " > Checking on WordPress installation at '#{app[:path]}'."
+
+        app[:prefix] = cmd_prefix(app)
+        wpcli = WordPress::WPCLI.new(app, options)
+        app   = WordPress::WPConfig.new(app, options)
+
+        # if options[:first_run] && 
+        wpcli.install if wpcli.version[:stderr] =~
+                         /Error: This does not seem to be a WordPress install/
+
+        siteurl = wpcli.siteurl
+        if siteurl =~ /http.*:\/\/(www.|)#{app[:domain]}/
+          puts "   |+ Siteurl: #{siteurl} found in the WP database. Continuing with deployment."
+        elsif siteurl =~ /Error: The site you have requested is not installed/
+          puts "   |! Domain: #{app[:domain]} not found in current database."
+
+          db_backup = app[:path] + '/' + app[:domain].gsub('.','_') + '.sql'
+          if File.exist?(db_backup) && options[:first_run]
+            puts "   |+ Importing from local backup."
+            import = wpcli.import
+          else
+            puts "   |- . No database content! Skipping deployment of #{app[:domain]}."
+            return app
+          end
+        else
+          puts "   ! Domain: #{app[:domain]} does not match the database's current siteurl: #{siteurl}"
+          puts "     |- Skipping #{app[:domain]} deployment"
+          return app
+        end
+          
+        if app[:autoupdate]
+          wpcli.update
+        else
+          wpcli.check_update
+        end
+
+        app.delete(:prefix)
+        app        
+      end
+        # if options[:pretend]
+          # puts "\tFake run: Skipping WordPress configuration for #{app[:domain]}"
+        # else
+          # verify_result = wp_ensure_installed(prefix, app, options)
+
+          # if verify_result[:stderr]
+          #   puts "   |+ Installing WordPress to: #{app[:path]}"
+          #   install_result = wp_install(prefix, app, options)
+          #   abort('   ! WordPress installation failed!') if install_result[:stderr]
+          #   verify_result = wp_ensure_installed(prefix, app, options)
+          #   abort('   ! WordPress verification failed!')  if verify_result[:stderr]
+          # end
+
+          # puts "   |+ WordPress #{verify_result[:stdout].chomp} found!" if verify_result[:stdout]
+          # app = verify_generate_wp_salts(app, options)
+          # DanarchyDeploy::Templater.new(app[:templates], options)
+        # end
+        
+        # puts "\n > Verifying wp-config.php for '#{app[:path]}/wp-config.php'."
+        # wp_config_new(app, options)
+      #   app
+      # end
+
+      private
+      def self.cmd_prefix(app)
+        "sudo -u #{app[:username]} bash -c "
+        # wp_root_mkdir(prefix, app, options)
+        # wp_cli_install(options)
+        # prefix
+      end
+
+      def self.wp_root_mkdir(prefix, app, options)
+        mkdir_cmd = prefix + "'test -d #{app[:path]} || mkdir -v #{app[:path]}'"
+        mkdir_result = DanarchyDeploy::Helpers.run_command(mkdir_cmd, options)
+
+        if mkdir_result[:stderr]
+          abort("   ! Failed to create directory: #{app[:path]}!")
+        elsif mkdir_result[:stdout]
+          puts "   |+ Created directory: #{app[:path]}"
+        end
+      end
+
+      def self.wp_cli_install(options)
+        wpcli_install = 'bash ' + File.expand_path(
+                          File.dirname(__FILE__) +
+                          '/wordpress/wpcli_install.sh')
+        wpcli_result = DanarchyDeploy::Helpers.run_command(wpcli_install, options)
+
+        if wpcli_result[:stderr]
+          abort('   ! WP-CLI installation failed!')
+        else
+          puts '   |+ WP-CLI installed.'
+        end
+      end
+
+      def self.wp_ensure_installed(prefix, app, options)
+        installed = false
+        version = nil
+        
+        if Dir.entries(app[:path]) == %w[. ..]
+          puts "   |+ Installing WordPress to: #{app[:path]}"
+          wp_install(prefix, app, options)
+          # wp_config_new(app, options)
+          # return 
+        end
+
+        version = wp_version(prefix, app, options)
+        # Error: This does not seem to be a WordPress install.
+      end
+
+      def self.wp_install(prefix, app, options)
+        cmd = prefix + "'wp core download --path=#{app[:path]}'"
+        DanarchyDeploy::Helpers.run_command(cmd, options)
+      end
+
+      def self.wp_update(prefix, app, options)
+        cmd = prefix + "'wp core update --path=#{app[:path]}'"
+        DanarchyDeploy::Helpers.run_command(cmd, options)
+      end
+
+      def self.wp_version(prefix, app, options)
+        cmd = prefix + "'wp core version --path=#{app[:path]}'"
+        DanarchyDeploy::Helpers.run_command(cmd, options)
+      end
+
+      def self.wp_verify_uptodate()
+        check_cmd = prefix + "'wp core check-update --path=#{app[:path]}'"
+        DanarchyDeploy::Helpers.run_command(check_cmd, options)
+      end
+
+      def self.wp_config_verify(prefix, app, options)
+        config_cmd = prefix + "wp config list DB_USER DB_PASSWORD DB_NAME DB_HOST table_prefix --path=#{app[:path]} --format=json"
+        wp_config_current = JSON.parse(`#{config_cmd}`)
+        p wp_config_current
+      end
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+module DanarchyDeploy
+  module Applicator
+    module WordPress
+      class WPCLI
+        def initialize(app, options)
+          puts "\n > Initializing WordPress CLI"
+          @database = app[:database]
+          @prefix   = app[:prefix]
+          @path     = app[:path]
+          @user     = app[:user]
+          @options  = options
+          wpcli_install
+        end
+
+        def install
+          cmd = @prefix + "'wp core download --path=#{@path}'"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def update
+          cmd = @prefix + "'wp core update --path=#{@path}'"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def version
+          cmd = @prefix + "'wp core version --path=#{@path}'"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def check_update
+          cmd = @prefix + "'wp core check-update --path=#{@path}'"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        def siteurl
+          cmd = @prefix + "'wp option get siteurl --path=#{@path}'"
+          siteurl = DanarchyDeploy::Helpers.run_command(cmd, @options)
+
+          if siteurl[:stdout]
+            return siteurl[:stdout].chomp
+          else
+            return siteurl[:stderr]
+          end
+        end
+
+        def import
+          cmd = @prefix + "'wp db import #{@database[:backup]} --path=#{@path}'"
+          DanarchyDeploy::Helpers.run_command(cmd, @options)
+        end
+
+        private
+
+        def wpcli_install
+          install_cmd = 'bash ' + __dir__ + '/wpcli_install.sh'
+          wpcli_result = DanarchyDeploy::Helpers.run_command(
+            install_cmd, @options)
+
+          if wpcli_result[:stderr]
+            abort('   ! WP-CLI installation failed!')
+          else
+            puts '   |+ WP-CLI installed.'
+          end
+        end
+      end
+    end
+  end
+end