danarchy_deploy 0.2.3 → 0.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9792fba2a8998890e49926fb51a20670a139b8f028f772eda429a4664b6090c9
-  data.tar.gz: 1dca75853aad2879cfe30bf7c8f15688c3fef4e81dbcb79b993afc5f8815645b
+  metadata.gz: d4665ec27120f6fda4337da5a2b2cb465511534cef96b47c2a11791076012f64
+  data.tar.gz: e12104840e0273bf38d37a0465752ebc5bacc53d2d0f4a5b5783a936f5810afb
 SHA512:
-  metadata.gz: 0b95c8e2bfeb5d1356edb6dd330533228f5a2a3961ec5caa66c6925bd48f6ed02a0eaeb73ea91772cb129d9adabc90e7dfbe0a33d164371e75f80e6cb0486eb0
-  data.tar.gz: 8f6aba47acd3bb2c71c2b0d20dac76e0bf340055209cd0908c23b46980ea2c4c70b4bc5793f24be71508787ab303b568fa915cddba93c8241e5f66be9f675f9f
+  metadata.gz: 4bc766ba4a3e8f6e0e691dd1904029f9c08cd6b040146214ae31fb0c18b3a779bae3258b033b1b50205f70c02ebfdbc1fcdd5756ae5ef7b727ce8225397cb4b4
+  data.tar.gz: 7b22f9218392944730cec707bbf62cf9cc9c696fd411eccf02e6d7ceff54748b141c76b2b3de6750867287e9221a17f0be08be524a29c58e14b38b6741da4036

data/.ruby-gemset

@@ -0,0 +1 @@
+danarchy_deploy

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.7.2

data/CHANGELOG.md

@@ -0,0 +1,48 @@
+patch_0.2.6
+- DanarchyDeploy: gem install --bindir
+- DanarchyDeploy: return from each class if not defined in a deployment
+- Services::MySQL: Check for defaults_file instead of /etc/my.cnf, SecureRandom.hex for passwords
+- Services::Init: clean up output and if statement
+- Add RVM .ruby-version .ruby-gemset
+- Rename danarchy_deploy-console to console-dd
+- Add CHANGELOG.md
+
+patch_0.2.5
+- Adds Fstab system service
+- Adds Dmcrypt/LVM system service
+- Enforce MongoDB security/limits.d/mongodb.conf if it doesn't exist
+- Clarify some CLI output
+- Ignore first SSH known_hosts error in RemoteDeploy.remote_mkdir
+
+patch_0.2.4
+- mongodb limits newlines
+
+patch_0.2.2
+- Fix MongoDB so it correctly applies security limits file count
+
+release_0.2.0
+- Adds Applicator #wordpress #nginx #phpfpm #ssl
+- Adds Services #init #mongodb #mysql
+- Adds System #centos #debian #gentoo #openssue
+
+patch_0.1.6
+- User/Groups commands should use sudo
+
+patch_0.1.5
+- Don't upload to couchdb if using a .json/.yaml template
+
+patch_0.1.4
+- sudoers.d/ file root owned
+
+patch_0.1.3
+- prevents packages from being an empty array
+
+patch_0.1.2
+- chown/chmod on ~/.ssh contents
+- fix JSON parse error
+
+release_0.1.1
+- Re-order archive extraction and template creation so that written templates aren't overwritten by archive data.
+- Fixes user sudoers.d file creation; a+ append instead of r+ read-write (expects file to exist already).
+- Cleans up package handling for Gentoo and also changes --usepkg to --buildpkg if hostname begins with 'image' or 'template' for binary creation during image builds.
+

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    danarchy_deploy (0.2.0)
-      danarchy_couchdb (~> 0.1.0)
-      mongo (~> 2.13)
+    danarchy_deploy (0.2.6)
+      danarchy_couchdb (~> 0.1)
+      mongo (~> 2.17)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    bson (4.10.1)
-    danarchy_couchdb (0.1.2)
-    mongo (2.13.1)
+    bson (4.14.1)
+    danarchy_couchdb (0.1.3)
+    mongo (2.17.0)
       bson (>= 4.8.2, < 5.0.0)
-    rake (13.0.1)
+    rake (13.0.6)
 
 PLATFORMS
-  ruby
+  x86_64-linux
 
 DEPENDENCIES
-  bundler (~> 2.1)
+  bundler (~> 2.3)
   danarchy_deploy!
   rake (~> 13.0)
 
 BUNDLED WITH
-   2.1.4
+   2.3.9

data/bin/danarchy_deploy

@@ -5,7 +5,7 @@ require 'date'
 require 'optparse'
 
 deployment = nil
-options = { couchdb: "#{ENV['HOME']}/.danarchy/danarchy_deploy/danarchy_deploy.json",
+options = { couchdb: "#{ENV['HOME']}/.danarchy/danarchy_deploy/danarchy_couchdb.json",
             deploy_dir: '/danarchy/deploy',
             deploy_file: nil,
             first_run: false,
@@ -15,7 +15,8 @@ options = { couchdb: "#{ENV['HOME']}/.danarchy/danarchy_deploy/danarchy_deploy.j
 
 ARGV.push('--help') if ARGV.empty?
 optparse = OptionParser.new do |opts|
-  opts.banner = "Usage: sudo #{$PROGRAM_NAME} (local|remote) --json /path/to/deployment.json [options]"
+  opts.banner  = "Usage: danarchy_deploy (local|remote) --json #{options[:deploy_dir]}/<HOSTNAME>/<HOSTNAME>.json [options]"
+  opts.banner += "\n  Local deployments require danarchy_deploy to be run as sudo/root.\n\n"
 
   opts.on('-j=file', '--json=file', 'Read configuration from JSON file.') do |file|
     require 'json'
@@ -65,7 +66,7 @@ optparse = OptionParser.new do |opts|
 end.parse!
 
 puts "DanarchyDeploy: #{DanarchyDeploy::VERSION}"
-location = ARGV.delete('remote') || ARGV.delete('local') || abort("ERROR: Need an option 'local' or 'remote' to know what to do!")
+location = ARGV.delete('remote') || ARGV.delete('local') || abort("ERROR: Need a deployment type: 'local' or 'remote'!")
 cdb_config = File.exist?(options[:couchdb]) ? JSON.parse(File.read(options[:couchdb]), symbolize_names: true)[:couchdb] : nil
 cdb = DanarchyCouchDB::Connection.new(cdb_config) if cdb_config
 
@@ -94,7 +95,7 @@ end
 if location == 'remote'
   deployment = DanarchyDeploy::RemoteDeploy.new(deployment, options)
 elsif location == 'local'
-  abort('Exiting! Must be run with sudo!') if Process.uid != 0
+  abort('Exiting! Local deployment must be run with sudo!') if Process.uid != 0
   puts "Deploying #{deployment[:hostname]} locally to #{`hostname`.chomp}."
 
   if !options[:pretend]
@@ -113,6 +114,7 @@ end
 
 if deployment && cdb && !options[:pretend] && options[:deploy_file] !~ /.*(json|yaml)$/
   puts "Saving deployment to CouchDB."
+  deployment[:_attachments].values.map { |v| v.delete(:data) } if deployment[:_attachments]
   old_rev = cdb.get(cdb_config[:database], deployment_name)[:_rev]
   save = cdb.put(cdb_config[:database], deployment[:_id], deployment)
 

data/danarchy_deploy.gemspec

@@ -28,10 +28,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "danarchy_couchdb", "~> 0.1.0"
+  spec.add_dependency "danarchy_couchdb", "~> 0.1"
 
-  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "bundler", "~> 2.3"
   spec.add_development_dependency "rake", "~> 13.0"
 
-  spec.add_runtime_dependency "mongo", "~> 2.13"
+  spec.add_runtime_dependency "mongo", "~> 2.17"
 end

data/lib/danarchy_deploy/groups.rb

@@ -2,6 +2,7 @@
 module DanarchyDeploy
   class Groups
     def self.new(deployment, options)
+      return deployment if ! deployment[:groups]
       puts "\n" + self.name
       (groupadd_result, groupdel_result) = nil
 

data/lib/danarchy_deploy/services/init.rb

@@ -5,6 +5,7 @@ module DanarchyDeploy
   module Services
     class Init
       def self.new(deployment, options)
+        return deployment if ! deployment[:services]
         puts "\n" + self.name
 
         deployment[:services].each do |service, params|
@@ -35,16 +36,16 @@ module DanarchyDeploy
 
         init_result = init.send(action)
 
-        if init_result[:stderr]
-          if init_result[:stderr].include?('unknown function')
+        if stderr = init_result[:stderr]
+          if 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!")
+            abort("       ! Action: #{action} #{service} failed!")
           end
         else
-          puts "       |+ Action: #{service} #{action} succeeded."
+          puts "       |+ Action: #{action} #{service} succeeded."
         end
       end
     end

data/lib/danarchy_deploy/services/mongodb.rb

@@ -13,7 +13,7 @@ module DanarchyDeploy
         Mongo::Logger.logger.level = Logger::FATAL
         mongodb_conf, updated_conf = self.load_mongodb_conf
         host_port = mongodb_conf['net']['bindIp'].split(',').first + ':' + mongodb_conf['net']['port'].to_s
-        admin_user, new_admin   = self.load_admin_user
+        admin_user, new_admin = self.load_admin_user
 
         if new_admin == true
           client = Mongo::Client.new(['127.0.0.1'], database: 'admin')
@@ -48,9 +48,7 @@ module DanarchyDeploy
       private
       def self.load_mongodb_conf
         updated_conf = false
-        @mongodb[:mongodb_conf] = @mongodb[:mongodb_conf] ?
-                                    @mongodb[:mongodb_conf] :
-                                    '/etc/mongodb.conf'
+        @mongodb[:mongodb_conf] ||= '/etc/mongodb.conf'
         mongodb_conf = File.exist?(@mongodb[:mongodb_conf]) ? YAML.load_file(@mongodb[:mongodb_conf]) : Hash.new
 
         generated_mongodb_conf = self.generate_mongodb_conf
@@ -59,13 +57,15 @@ module DanarchyDeploy
       end
 
       def self.generate_mongodb_conf
-        if File.readlines('/etc/security/limits.conf').grep(/mongodb/).empty?
-          entry =  'mongodb         soft     nofile          32000\n'
-          entry += 'mongodb         hard     nofile          64000\n'
-          File.open('/etc/security/limits.conf', 'a+') do |f|
-            f.write entry
-          end
-        end
+        security_limits = '/etc/security/limits.d/mongodb.conf'
+        limits = <<~EOF
+        mongodb         soft     nofile          64000
+        mongodb         hard     nofile          64000
+        mongodb         soft     nproc           64000
+        mongodb         hard     nproc           64000
+        EOF
+
+        File.write(security_limits, limits) if !File.exist?(security_limits)
 
         mongodb_conf = {
           'net'       => { 'port'    => 27017, 'bindIp' => '127.0.0.1' },

data/lib/danarchy_deploy/services/mysql/new_server.rb

@@ -49,13 +49,13 @@ module DanarchyDeploy
         end
 
         def self.generate_root_mycnf(mysql, options)
-          return if File.exist?(mysql[:default_file])
-          puts "   |+ Generating #{mysql[:default_file]} file."
-          password = SecureRandom.base64(14)
+          return if File.exist?(mysql[:defaults_file])
+          puts "   |+ Generating #{mysql[:defaults_file]} file."
+          password = SecureRandom.hex(24)
           source = options[:deploy_dir] +
                    '/templates/services/mysql/root_my.cnf.erb'
 
-          templates = [{ target: mysql[:default_file],
+          templates = [{ target: mysql[:defaults_file],
                          source: source,
                          variables: {
                            host: 'localhost',

data/lib/danarchy_deploy/services/mysql.rb

@@ -11,7 +11,7 @@ module DanarchyDeploy
         mysql = self.set_parameters(mysql)
         self.generate_my_cnf(mysql, options)
 
-        if File.exist?(mysql[:my_cnf]) && Dir.exist?(mysql[:datadir] + '/mysql')
+        if File.exist?(mysql[:defaults_file]) && Dir.exist?(mysql[:datadir])
           puts "   |+ Using existing MySQL service."
         else
           MySQL::NewServer.new(os, mysql, options)
@@ -24,8 +24,8 @@ module DanarchyDeploy
       end
 
       def self.set_parameters(mysql)
-        mysql[:default_file] = mysql[:default_file] ?
-                                 mysql[:default_file] :
+        mysql[:defaults_file] = mysql[:defaults_file] ?
+                                 mysql[:defaults_file] :
                                  '/root/.my.cnf'
         mysql[:my_cnf] = mysql[:my_cnf] ?
                            mysql[:my_cnf] :

data/lib/danarchy_deploy/services.rb

@@ -6,6 +6,7 @@ require_relative 'services/mysql'
 module DanarchyDeploy
   module Services
     def self.new(deployment, options)
+      return deployment if ! deployment[:services]
       puts "\n" + self.name
 
       deployment[:services].each do |service, params|

data/lib/danarchy_deploy/system/cryptsetup.rb

@@ -0,0 +1,144 @@
+
+module DanarchyDeploy
+  module System
+    class Cryptsetup
+      def self.new(os, cryptsetup, options)
+        return false if cryptsetup.nil?
+        puts "\n" + self.name
+
+        # expects object: {
+        # "cryptsetup": {
+        #       "source": "/danarchy/deploy/templates/system/cryptsetup.erb", (optional)
+        #       "volumes": {
+        #               "vg_name:vg0:/dev/vdb": {
+        #                       "target": "dm-vg0-mongodb",
+        #                       "source": "/dev/mapper/vg0-mongodb",
+        #                       "key": "/root/vdb_mongodb.key" } } } }
+
+        if os == 'gentoo'
+          DanarchyDeploy::Services::Init.init_manager(os, 'lvmetad', 'enable', options)
+          DanarchyDeploy::Services::Init.init_manager(os, 'lvmetad', 'start', options)
+        end
+
+        service, target, source = set_config(cryptsetup, options)
+        lvm_result, crypt_result = nil
+        cryptsetup[:volumes].each do |device, volume|
+          lvm_result   = lvm_setup(device, volume, options)
+          crypt_result = encrypt_volume(volume, options)
+        end
+
+        deploy_template(target, source, cryptsetup[:volumes], options)
+        if os == 'gentoo'
+          DanarchyDeploy::Services::Init.init_manager(os, service, 'enable', options)
+          DanarchyDeploy::Services::Init.init_manager(os, service, 'start', options)
+        end
+      end
+
+      private
+      def self.set_config(cryptsetup, options)
+        service, target = File.exist?('/etc/conf.d/dmcrypt') ?
+                            ['dmcrypt','/etc/conf.d/dmcrypt'] :
+                            ['cryptsetup','/etc/crypttab']
+
+        source = if cryptsetup[:source]
+                   cryptsetup[:source]
+                 elsif target == '/etc/conf.d/dmcrypt'
+                   options[:deploy_dir] + '/templates/system/dmcrypt.erb'
+                 elsif target == '/etc/crypttab'
+                   options[:deploy_dir] + '/templates/system/crypttab.erb'
+                 else
+                   nil
+                 end
+
+        [service, target, source]
+      end
+
+      def self.lvm_setup(device, volume, options)
+        puts "\n > Configuring LVM"
+        name, vg, pv = device.to_s.split(/:/)
+
+        # Create physical volume
+        pvdisplay = DanarchyDeploy::Helpers.run_command("pvdisplay #{pv}", options)
+        if pvdisplay[:stderr]
+          puts "Creating physical volume: #{pv}"
+          pvcreate = DanarchyDeploy::Helpers.run_command("pvcreate -f #{pv}", options)
+          abort("   ! Failed to run pvcreate: #{pvcreate[:stderr]}") if pvcreate[:stderr]
+          puts pvcreate[:stdout]
+          pvdisplay = DanarchyDeploy::Helpers.run_command("pvdisplay #{pv}", options)
+        end
+        puts pvdisplay[:stderr] || pvdisplay[:stdout]
+
+        # Create volume group
+        vgdisplay = DanarchyDeploy::Helpers.run_command("vgdisplay #{vg}", options)
+        if vgdisplay[:stderr]
+          puts "Creating volume group: #{vg} with #{pv}"
+          vgcreate = DanarchyDeploy::Helpers.run_command("vgcreate #{vg} #{pv}", options)
+          abort("   ! Failed to run vgcreate: #{vgcreate[:stderr]}") if vgcreate[:stderr]
+          puts vgcreate[:stdout]
+          vgdisplay = DanarchyDeploy::Helpers.run_command("vgdisplay #{vg}", options)
+        end
+        puts vgdisplay[:stderr] || vgdisplay[:stdout]
+
+        # Create logical volume
+        lvdisplay = DanarchyDeploy::Helpers.run_command("lvdisplay #{vg}/#{name}", options)
+        if lvdisplay[:stderr]
+          puts "Creating volume group: #{vg}/#{name} with #{pv}"
+          lvcreate = DanarchyDeploy::Helpers.run_command("lvcreate -y -l 100%FREE -n #{name} #{vg}", options)
+          abort("   ! Failed to run lvcreate: #{lvcreate[:stderr]}") if lvcreate[:stderr]
+          puts lvcreate[:stdout]
+          lvdisplay = DanarchyDeploy::Helpers.run_command("lvdisplay #{vg}/#{name}", options)
+        end
+        puts lvdisplay[:stderr] || lvdisplay[:stdout]
+
+        [pvdisplay, vgdisplay, lvdisplay]
+      end
+
+      def self.encrypt_volume(volume, options)
+        puts "\n > Configuring Cryptsetup"
+        deploy_key(volume, options)
+        target = volume[:variables][:target]
+        source = volume[:variables][:source]
+        key    = volume[:variables][:key]
+        abort("  ! Failed to find key: #{key}") if !File.exist?(key) && !options[:pretend]
+        
+        # Encrypt logical volume with key
+        luksdump = DanarchyDeploy::Helpers.run_command("cryptsetup luksDump #{source}", options)
+        if luksdump[:stderr]
+          puts "\n   > Encrypting volume: #{source}"
+          luksformat = DanarchyDeploy::Helpers.run_command("cryptsetup luksFormat #{source} #{key}", options)
+          abort("     ! Failed to run luksFormat: #{luksformat[:stderr]}") if luksformat[:stderr]
+          puts luksformat[:stdout]
+          luksdump = DanarchyDeploy::Helpers.run_command("cryptsetup luksDump #{source}", options)
+        end
+        puts luksdump[:stderr] || luksdump[:stdout]
+
+        # Open luks target
+        luksopen = { stderr: nil }
+        if !File.exist?("/dev/mapper/#{target}")
+          puts "\n   > Opening volume: #{source}"
+          luksopen = DanarchyDeploy::Helpers.run_command("cryptsetup luksOpen -d #{key} #{source} #{target}", options)
+          abort("     ! Failed to run luksOpen: #{luksopen[:stderr]}") if luksopen[:stderr]
+          puts luksopen[:stdout]
+        end
+
+        [luksdump, luksopen]
+      end
+
+      def self.deploy_key(volume, options)
+        templates = [{ source: volume[:key_file],
+                       target: volume[:variables][:key],
+                       file_perms: {
+                         owner: 'root',
+                         group: 'root',
+                         mode:  '0400' } }]
+        
+        DanarchyDeploy::Templater.new(templates, options)
+      end
+
+      def self.deploy_template(target, source, volumes, options)
+        templates = [{ target: target, source: source, variables: volumes }]
+        DanarchyDeploy::Templater.new(templates, options)
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/system/fstab.rb

@@ -0,0 +1,60 @@
+
+module DanarchyDeploy
+  module System
+    class Fstab
+      def self.new(os, fstab, options)
+        puts "\n" + self.name
+        target, source = set_config(fstab, options)
+        deploy_template(target, source, fstab[:mounts], options)
+        format_mountpoints(fstab, options)
+        mount_all(options)
+      end
+
+      def self.mount_all(options)
+        puts "\n > Mounting Filesystems"
+        mount_result = DanarchyDeploy::Helpers.run_command('mount -a', options)
+        abort('    ! Failed to mount filesystems!') if mount_result[:stderr]
+      end
+
+      private
+      def self.set_config(fstab, options)
+        target = '/etc/fstab'
+        source = fstab[:source] ?
+                   fstab[:source] :
+                   '/danarchy/deploy/templates/system/fstab.erb'
+
+        [target, source]
+      end
+
+      def self.deploy_template(target, source, mounts, options)
+        templates = [{ target: target,
+                       source: source,
+                       variables: mounts }]
+
+        DanarchyDeploy::Templater.new(templates, options)
+      end
+
+      def self.format_mountpoints(fstab, options)
+        return false if fstab.nil?
+        puts "\n > Formatting mountpoints"
+
+        fstab[:mounts].each do |mount|
+          fs_check = DanarchyDeploy::Helpers.run_command(
+            "file -sL #{mount[:filesystem]}", options
+          )
+
+          if fs_check[:stdout] && fs_check[:stdout] =~ /.*data$/
+            puts "\n   > Formatting #{mount[:filesystem]}"
+            mkfs = DanarchyDeploy::Helpers.run_command(
+              "mkfs -t #{mount[:type]} #{mount[:filesystem]}", options
+            )
+            abort("    ! Failed to run mkfs: #{mkfs[:stderr]}") if mkfs[:stderr]
+          end
+
+          FileUtils.mkdir_p(mount[:mountpoint]) if !options[:pretend] &&
+                                                   !Dir.exist?(mount[:mountpoint])
+        end
+      end
+    end
+  end
+end

data/lib/danarchy_deploy/system.rb

@@ -3,10 +3,14 @@ require_relative 'system/debian'
 require_relative 'system/gentoo'
 require_relative 'system/opensuse'
 
+require_relative 'system/cryptsetup'
+require_relative 'system/fstab'
+
 module DanarchyDeploy
   module System
     def self.new(deployment, options)
       abort('Operating System not defined! Exiting!') if !deployment[:os]
+      return deployment if ! deployment[:system]
       puts "\n" + self.name
 
       installer, updater, cleaner = prep_operating_system(deployment, options)
@@ -46,28 +50,17 @@ module DanarchyDeploy
         if deployment[:system][:templates]
           puts "\n > Configuring system templates for #{deployment[:os]}"
           DanarchyDeploy::Templater.new(deployment[:system][:templates], options)
+        end
 
-          # Add deployment[:system][:dmcrypt], deployment[:system][:lvm], and deployment[:system][:fstab] here
-          deployment[:system][:templates].each do |t|
-            if t[:target] == '/etc/fstab'
-              t[:variables].each do |v|
-                if !Dir.exist?(v[:mountpoint])
-                  puts "Creating mountpoint: #{v[:mountpoint]}"
-                  FileUtils.mkdir_p(v[:mountpoint]) if !options[:pretend]
-                end
-              end
-            end
-          end
+        DanarchyDeploy::System::Cryptsetup.new(deployment[:os], deployment[:system][:cryptsetup], options)
 
+        if deployment[:system][:fstab]
+          DanarchyDeploy::System::Fstab.new(deployment[:os], deployment[:system][:fstab], options)
+        else
+          DanarchyDeploy::System::Fstab.mount_all(options)
         end
       end
 
-      puts "\n > Mounting Filesystems"
-      if !options[:pretend]
-        mount_result = DanarchyDeploy::Helpers.run_command('mount -a', options)
-        abort('   |! Failed to mount filesystems!') if mount_result[:stderr]
-      end
-
       if os.downcase == 'gentoo'
         (installer, updater, cleaner) = DanarchyDeploy::System::Gentoo.new(deployment, options)
       elsif %w[debian ubuntu].include?(os.downcase)
@@ -75,12 +68,30 @@ module DanarchyDeploy
       elsif os.downcase == 'opensuse'
         puts 'OpenSUSE is not fully supported yet!'
         (installer, updater, cleaner) = DanarchyDeploy::System::OpenSUSE.new(deployment, options)
-      elsif %w[centos redhat].include?(os.downcase)
-        puts 'CentOS/RedHat is not fully supported yet!'
+      elsif %w[fedora centos redhat].include?(os.downcase)
+        puts 'Fedora/CentOS/RedHat is not fully supported yet!'
         (installer, updater, cleaner) = DanarchyDeploy::System::CentOS.new(deployment, options)
       end
 
       [installer, updater, cleaner]
     end
+
+    def self.fstab_mount(deployment, options)
+      fstab = deployment[:system][:templates].collect { |t| t if t[:target] == '/etc/fstab' }.compact
+      fstab.each do |t|
+        t[:variables].each do |v|
+          if !Dir.exist?(v[:mountpoint])
+            puts "Creating mountpoint: #{v[:mountpoint]}"
+            FileUtils.mkdir_p(v[:mountpoint]) if !options[:pretend]
+          end
+        end
+      end
+
+      puts "\n > Mounting Filesystems"
+      if !options[:pretend]
+        mount_result = DanarchyDeploy::Helpers.run_command('mount -a', options)
+        abort('   |! Failed to mount filesystems!') if mount_result[:stderr]
+      end
+    end
   end
 end

data/lib/danarchy_deploy/users.rb

@@ -2,6 +2,7 @@
 module DanarchyDeploy
   class Users
     def self.new(deployment, options)
+      return deployment if ! deployment[:users]
       puts "\n" + self.name
       (useradd_result, userdel_result, archives_result) = nil
 
@@ -56,7 +57,6 @@ module DanarchyDeploy
         user.delete(:username)
       end
 
-      # [useradd_result, userdel_result]
       deployment
     end
 

data/lib/danarchy_deploy/version.rb

@@ -1,3 +1,3 @@
 module DanarchyDeploy
-  VERSION = "0.2.3"
+  VERSION = "0.2.6"
 end

data/lib/danarchy_deploy.rb

@@ -21,10 +21,10 @@ module DanarchyDeploy
       printf("%12s %0s\n", 'Packages:', deployment[:packages].join(', '))  if deployment[:packages]
 
       deployment = DanarchyDeploy::System.new(deployment, options)
-      deployment = DanarchyDeploy::Services.new(deployment, options)       if deployment[:services]
-      deployment = DanarchyDeploy::Groups.new(deployment, options)         if deployment[:groups]
-      deployment = DanarchyDeploy::Users.new(deployment, options)          if deployment[:users]
-      deployment = DanarchyDeploy::Services::Init.new(deployment, options) if deployment[:services]
+      deployment = DanarchyDeploy::Services.new(deployment, options)
+      deployment = DanarchyDeploy::Groups.new(deployment, options)
+      deployment = DanarchyDeploy::Users.new(deployment, options)
+      deployment = DanarchyDeploy::Services::Init.new(deployment, options)
 
       deployment[:last_deploy] = DateTime.now.strftime("%Y/%m/%d %H:%M:%S")
       puts "\nFinished Local Deployment at #{deployment[:last_deploy]}!"
@@ -61,7 +61,7 @@ module DanarchyDeploy
 
       gem_clean(connector, options)
       gem_binary = _locate_gem_binary(connector, options) # this should run before any install; check version too
-      push_temmplates(connector, options)
+      push_templates(connector, options)
       push_deployment(connector, options)
       deploy_result = remote_LocalDeploy(connector, gem_binary, options)
 
@@ -79,10 +79,10 @@ module DanarchyDeploy
     private
     def self.remote_mkdir(connector, options)
       puts "\n > Creating directory: #{options[:working_dir]}"
-      mkdir_cmd = _ssh_command(connector, "test -d #{options[:working_dir]} || sudo mkdir -vp #{options[:working_dir]}")
+      mkdir_cmd = _ssh_command(connector, "test -d #{options[:working_dir]} && echo 'Directory exists!' || sudo mkdir -vp #{options[:working_dir]}")
       mkdir_result = DanarchyDeploy::Helpers.run_command(mkdir_cmd, options)
 
-      if mkdir_result[:stderr]
+      if mkdir_result[:stderr] && ! mkdir_result[:stdout]
         abort('   ! Directory creation failed!')
       else
         puts "   |+ Created directory: '#{options[:deploy_dir]}'"
@@ -144,7 +144,7 @@ module DanarchyDeploy
       end
       
       puts "\n > Installing gem: #{gem} on #{connector[:hostname]}"
-      install_cmd = _ssh_command(connector, "sudo gem install -f #{options[:deploy_dir]}/#{File.basename(gem)}")
+      install_cmd = _ssh_command(connector, "sudo gem install --bindir /usr/local/bin -f #{options[:deploy_dir]}/#{File.basename(gem)}")
       install_result = DanarchyDeploy::Helpers.run_command(install_cmd, options)
 
       if install_result[:stderr]
@@ -159,7 +159,7 @@ module DanarchyDeploy
       system(clean_cmd)
     end
 
-    def self.push_temmplates(connector, options)
+    def self.push_templates(connector, options)
       template_dir = options[:deploy_dir] + '/templates'
       puts "\n > Pushing templates: #{template_dir}"
       push_cmd = _rsync_push(connector, template_dir, template_dir)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danarchy_deploy
 version: !ruby/object:Gem::Version
-  version: 0.2.3
+  version: 0.2.6
 platform: ruby
 authors:
 - Dan James
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2022-05-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: danarchy_couchdb
@@ -16,28 +16,28 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.1.0
+        version: '0.1'
 - !ruby/object:Gem::Dependency
   name: bundler
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.3'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.1'
+        version: '2.3'
 - !ruby/object:Gem::Dependency
   name: rake
   requirement: !ruby/object:Gem::Requirement
@@ -58,35 +58,38 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.17'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '2.13'
+        version: '2.17'
 description: DanarchyDeploy intends to simplify Gentoo Linux (and other distro) deployments
   down to a single template from an input JSON or YAML file, or from a CouchDB file.
 email:
 - dan@danarchy.me
 executables:
+- console-dd
 - danarchy_deploy
-- danarchy_deploy-console
 - setup
 extensions: []
 extra_rdoc_files: []
 files:
 - ".gitignore"
 - ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
 - ".travis.yml"
+- CHANGELOG.md
 - Gemfile
 - Gemfile.lock
 - LICENSE.txt
 - README.md
 - Rakefile
+- bin/console-dd
 - bin/danarchy_deploy
-- bin/danarchy_deploy-console
 - bin/setup
 - danarchy_deploy.gemspec
 - lib/danarchy_deploy.rb
@@ -115,7 +118,9 @@ files:
 - lib/danarchy_deploy/services/mysql/privileges.rb
 - lib/danarchy_deploy/system.rb
 - lib/danarchy_deploy/system/centos.rb
+- lib/danarchy_deploy/system/cryptsetup.rb
 - lib/danarchy_deploy/system/debian.rb
+- lib/danarchy_deploy/system/fstab.rb
 - lib/danarchy_deploy/system/gentoo.rb
 - lib/danarchy_deploy/system/opensuse.rb
 - lib/danarchy_deploy/templater.rb
@@ -127,7 +132,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -142,8 +147,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.1.4
+signing_key:
 specification_version: 4
 summary: Pushes deployments locally or remotely based on a JSON/YAML/CouchDB template.
 test_files: []