danarchy_deploy 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b5d4b100fde493fb91243e22403bac644464abadb83dbad8349b176e446c89be
-  data.tar.gz: c84e887dad0c9c2f642a761b0f664a974e262092022f121446301b69f78a1694
+  metadata.gz: f00a848b7b3326a27f07e661d2a0f79593cd8bb4140664e7fd86de1429a428a5
+  data.tar.gz: 91d62fdeff9560e8178bfe00b214c15740d53f785003f33a38d10c22878e5be5
 SHA512:
-  metadata.gz: d2fce9b195ce710f30e7d8c106cef2a5e7623ba2c8afed51056bc7bfe88f3744129eb09139adf87217a00c40d52e319406330d020eb530029c41ac79921bf6a7
-  data.tar.gz: ffd1aaef29c57166f6c834ae150f5e95fe9fa1af791023666ca20416d29af611ed1a409a6bb7b52aa7871664633d9bf5281a26b20073174c31119b29f862e617
+  metadata.gz: afb687e9d4df549f12bb3d14d6acf235020d288617ceba418eee50d7806da84d002491b1beb62056484a71e047aa91cac02b40d60afe7b8a073980550dc52af9
+  data.tar.gz: 8db9fa38eaedc05cc48074a690176764be983cdf9b18538773ee63d55de1c039a835f3c962df23d6970b725a0299cee9ea81f3aaee0e02c3244451caf46d6552

data/Gemfile.lock

@@ -1,26 +1,26 @@
 PATH
   remote: .
   specs:
-    danarchy_deploy (0.2.4)
-      danarchy_couchdb (~> 0.1.0)
-      mongo (~> 2.13)
+    danarchy_deploy (0.2.5)
+      danarchy_couchdb (~> 0.1)
+      mongo (~> 2.17)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    bson (4.11.0)
-    danarchy_couchdb (0.1.2)
-    mongo (2.13.1)
+    bson (4.14.0)
+    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.3

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 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/services/mongodb.rb

@@ -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/system/cryptsetup.rb

@@ -0,0 +1,140 @@
+
+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
+
+      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
+
+      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
+    end
+  end
+end

data/lib/danarchy_deploy/system.rb

@@ -3,6 +3,9 @@ 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)
@@ -29,6 +32,8 @@ module DanarchyDeploy
         puts cleanup_result[:stdout] if cleanup_result[:stdout]
       end
 
+      DanarchyDeploy::System::Cryptsetup.new(deployment[:os], deployment[:system][:cryptsetup], options)
+      DanarchyDeploy::System::Fstab.new(deployment[:os], deployment[:system][:fstab], options)
       deployment
     end
 
@@ -46,28 +51,9 @@ module DanarchyDeploy
         if deployment[:system][:templates]
           puts "\n > Configuring system templates for #{deployment[:os]}"
           DanarchyDeploy::Templater.new(deployment[:system][:templates], options)
-
-          # 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
-
         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)
@@ -82,5 +68,23 @@ module DanarchyDeploy
 
       [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/version.rb

@@ -1,3 +1,3 @@
 module DanarchyDeploy
-  VERSION = "0.2.4"
+  VERSION = "0.2.5"
 end

data/lib/danarchy_deploy.rb

@@ -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]}'"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: danarchy_deploy
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - Dan James
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2020-10-21 00:00:00.000000000 Z
+date: 2022-01-20 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,14 +58,14 @@ 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:
@@ -115,7 +115,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 +129,7 @@ licenses:
 - MIT
 metadata:
   allowed_push_host: https://rubygems.org
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -142,8 +144,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.2.33
+signing_key:
 specification_version: 4
 summary: Pushes deployments locally or remotely based on a JSON/YAML/CouchDB template.
 test_files: []