danarchy_deploy 0.1.5 → 0.2.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: a482f91406ebff209e507ae56bc4be82c8c7ca80
-  data.tar.gz: 0c0d2dff7477e981dcd057ad2f5919dc92758309
+SHA256:
+  metadata.gz: b5d4b100fde493fb91243e22403bac644464abadb83dbad8349b176e446c89be
+  data.tar.gz: c84e887dad0c9c2f642a761b0f664a974e262092022f121446301b69f78a1694
 SHA512:
-  metadata.gz: 368cbeddce75725922abe8412e89bb2d74baa9c06a4dc86ee9523e6cddb733dfb77e80b9ab92beda895d80a736f908231732a78b938fe3147cb918e3dd0915be
-  data.tar.gz: 26416496b1c7c096b108161ed2f5ef40a972dd6c4555a26cd3efd16f58ab0a9c02b1ad26c4a5720976119b4cadc83b77ceddd84e8a743d63de5079b2dfaaff83
+  metadata.gz: d2fce9b195ce710f30e7d8c106cef2a5e7623ba2c8afed51056bc7bfe88f3744129eb09139adf87217a00c40d52e319406330d020eb530029c41ac79921bf6a7
+  data.tar.gz: ffd1aaef29c57166f6c834ae150f5e95fe9fa1af791023666ca20416d29af611ed1a409a6bb7b52aa7871664633d9bf5281a26b20073174c31119b29f862e617

data/.gitignore

@@ -1,3 +1,4 @@
+*~
 /.bundle/
 /.yardoc
 /_yardoc/

data/Gemfile.lock

@@ -1,37 +1,26 @@
 PATH
   remote: .
   specs:
-    danarchy_deploy (0.1.0)
+    danarchy_deploy (0.2.4)
       danarchy_couchdb (~> 0.1.0)
+      mongo (~> 2.13)
 
 GEM
   remote: https://rubygems.org/
   specs:
+    bson (4.11.0)
     danarchy_couchdb (0.1.2)
-    diff-lcs (1.3)
-    rake (10.5.0)
-    rspec (3.7.0)
-      rspec-core (~> 3.7.0)
-      rspec-expectations (~> 3.7.0)
-      rspec-mocks (~> 3.7.0)
-    rspec-core (3.7.1)
-      rspec-support (~> 3.7.0)
-    rspec-expectations (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-mocks (3.7.0)
-      diff-lcs (>= 1.2.0, < 2.0)
-      rspec-support (~> 3.7.0)
-    rspec-support (3.7.1)
+    mongo (2.13.1)
+      bson (>= 4.8.2, < 5.0.0)
+    rake (13.0.1)
 
 PLATFORMS
   ruby
 
 DEPENDENCIES
-  bundler (~> 1.16)
+  bundler (~> 2.1)
   danarchy_deploy!
-  rake (~> 10.0)
-  rspec (~> 3.0)
+  rake (~> 13.0)
 
 BUNDLED WITH
-   1.16.1
+   2.1.4

data/README.md

@@ -19,28 +19,29 @@ Or install it yourself as:
 
     $ gem install danarchy_deploy
 
-!! Since dAnarchy Deploy takes several actions that require root/sudo access, I install the gem with sudo as any remote deployment will on the target host:
 
-    $ sudo gem install danarchy_deploy
+If you will be running dAnarchy Deploy as a LocalDeploy, it will require root/sudo access, so install the gem with sudo.
+   This is RemoteDeploy's process for running LocalDeploy on target hosts (DanarchyDeploy::RemoteDeploy#gem_install [L99-L109]):
+
+   $ sudo gem install danarchy_deploy
 
 
 ## Usage
 
 dAnarchy Deploy usage info can be read with -h/--help:
 ```ruby
-$ danarchy_deploy -h
-Usage: sudo /usr/local/bin/danarchy_deploy (local|remote) --json /path/to/deployment.json [options]
+~$ danarchy_deploy -h
+Usage: sudo bin/danarchy_deploy (local|remote) --json /path/to/deployment.json [options]
 	-j, --json=file                  Read configuration from JSON file.
 	-y, --yaml=file                  Read configuration from YAML file.
 	-p, --pretend                    Pretend run: Don't take any action.
 	-f, --first-run                  First Run: Run as a first run causing services to run all init actions.
 	-d, --deploy-dir                 Deployment directory. Defaults to '/danarchy/deploy'.
-	--ssh-verbose                Verbose SSH stdout/stderr output.
-	--version                    Print /usr/local/bin/danarchy_deploy version.
+	--dev-gem    			 Build dAnarchy_deploy gem locally and push to target host in RemoteDeploy.
+	--ssh-verbose                	 Verbose SSH stdout/stderr output.
+	--vars-verbose                	 Verbose template variable output.
+	--version                    	 Print bin/danarchy_deploy version.
 	-h, --help                       Print this help info.
-
-DanarchyDeploy: 0.1.0
-Exiting! Must be run with sudo!
 ```
 
 More documentation incoming...

data/Rakefile

@@ -1,6 +1,2 @@
 require "bundler/gem_tasks"
-require "rspec/core/rake_task"
-
-RSpec::Core::RakeTask.new(:spec)
-
 task :default => :spec

data/bin/danarchy_deploy

@@ -5,12 +5,13 @@ require 'date'
 require 'optparse'
 
 deployment = nil
-options = { couchdb: "/home/#{ENV['SUDO_USER']}/.danarchy/danarchy_deploy/danarchy_deploy.json",
+options = { couchdb: "#{ENV['HOME']}/.danarchy/danarchy_deploy/danarchy_deploy.json",
             deploy_dir: '/danarchy/deploy',
             deploy_file: nil,
+            first_run: false,
             pretend: false,
             ssh_verbose: false,
-            first_run: false }
+            vars_verbose: false }
 
 ARGV.push('--help') if ARGV.empty?
 optparse = OptionParser.new do |opts|
@@ -32,34 +33,44 @@ optparse = OptionParser.new do |opts|
     options[:pretend] = true
   end
 
-  opts.on('-f', '--first-run', 'First Run: Run as a first run causing services to run all init actions.') do |val|
-    options[:first_run] = true
-  end
-
   opts.on('-d', '--deploy-dir', "Deployment directory. Defaults to '/danarchy/deploy'.") do |val|
     options[:deploy_dir] = val.gsub(/\/$/, '')
   end
 
+  opts.on('--dev-gem', 'Build dAnarchy_deploy gem locally and push to target host in RemoteDeploy.') do |val|
+    options[:dev_gem] = true
+  end
+
+  opts.on('-f', '--first-run', 'First Run: Run as a first run causing services to run all init actions.') do |val|
+    options[:first_run] = true
+  end
+
   opts.on('--ssh-verbose', "Verbose SSH stdout/stderr output.") do |val|
     options[:ssh_verbose] = true
   end
 
+  opts.on('--vars-verbose', "Verbose template variables and diff output.") do |val|
+    options[:vars_verbose] = true
+  end
+
   opts.on('--version', "Print #{$PROGRAM_NAME} version.") do |val|
     puts "DanarchyDeploy: #{DanarchyDeploy::VERSION}"
+    exit 1
   end
 
   opts.on('-h', '--help', 'Print this help info.') do |val|
-    puts opts, ''
+    puts opts
+    exit 1
   end
 end.parse!
 
 puts "DanarchyDeploy: #{DanarchyDeploy::VERSION}"
-abort('Exiting! Must be run with sudo!') if Process.uid != 0
-
 location = ARGV.delete('remote') || ARGV.delete('local') || abort("ERROR: Need an option 'local' or 'remote' to know what to do!")
 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
 
+# Error handling for !cdb_config && !input_file
+
 if !deployment && !options[:deploy_file] && cdb
   deployment_name = ARGV.shift
   abort("Need a deployment name!") if !deployment_name
@@ -71,6 +82,8 @@ if !deployment && !options[:deploy_file] && cdb
   options[:deploy_file] = "#{options[:deploy_dir]}/#{deployment_name}/#{deployment_name}.json"
   puts "Temp JSON path: #{options[:deploy_file]}"
   File.write(options[:deploy_file], deployment.to_json)
+elsif !deployment && !cdb
+  abort('ERROR: No --json or --yaml file was provided, nor was a CouchDB connection found.')
 end  
 
 if !deployment[:last_deploy] || deployment[:last_deploy].empty?
@@ -81,6 +94,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
   puts "Deploying #{deployment[:hostname]} locally to #{`hostname`.chomp}."
 
   if !options[:pretend]

data/danarchy_deploy.gemspec

@@ -30,7 +30,8 @@ Gem::Specification.new do |spec|
 
   spec.add_dependency "danarchy_couchdb", "~> 0.1.0"
 
-  spec.add_development_dependency "bundler", "~> 1.16"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "bundler", "~> 2.1"
+  spec.add_development_dependency "rake", "~> 13.0"
+
+  spec.add_runtime_dependency "mongo", "~> 2.13"
 end

data/lib/danarchy_deploy.rb

@@ -1,13 +1,14 @@
-require_relative 'danarchy_deploy/version'
-
 module DanarchyDeploy
-  require_relative './danarchy_deploy/archiver'
-  require_relative './danarchy_deploy/groups'
-  require_relative './danarchy_deploy/helpers'
-  require_relative './danarchy_deploy/installer'
-  require_relative './danarchy_deploy/users'
-  require_relative './danarchy_deploy/services'
-  require_relative './danarchy_deploy/templater'
+  require_relative 'danarchy_deploy/applicator'
+  require_relative 'danarchy_deploy/archiver'
+  require_relative 'danarchy_deploy/groups'
+  require_relative 'danarchy_deploy/hash_deep_merge'
+  require_relative 'danarchy_deploy/helpers'
+  require_relative 'danarchy_deploy/services'
+  require_relative 'danarchy_deploy/system'
+  require_relative 'danarchy_deploy/templater'
+  require_relative 'danarchy_deploy/users'
+  require_relative 'danarchy_deploy/version'
 
   class LocalDeploy
     def self.new(deployment, options)
@@ -17,19 +18,23 @@ module DanarchyDeploy
       puts 'Begining Deployment:'
       printf("%12s %0s\n", 'Hostname:', deployment[:hostname])
       printf("%12s %0s\n", 'OS:', deployment[:os])
-      printf("%12s %0s\n", 'Packages:', deployment[:packages].join(', ')) if deployment[:packages]
+      printf("%12s %0s\n", 'Packages:', deployment[:packages].join(', '))  if deployment[:packages]
 
-      deployment = DanarchyDeploy::Installer.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(deployment, options) if deployment[:services]
+      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[:last_deploy] = DateTime.now.strftime("%Y/%m/%d %H:%M:%S")
       puts "\nFinished Local Deployment at #{deployment[:last_deploy]}!"
-      File.write(options[:deploy_file],
-                 JSON.pretty_generate(deployment)) if options[:deploy_file].end_with?('.json')
-      File.write(options[:deploy_file], deployment.to_yaml) if options[:deploy_file].end_with?('.yaml')
+
+      if options[:deploy_file].end_with?('.json')
+        File.write(options[:deploy_file], JSON.pretty_generate(deployment))
+      elsif options[:deploy_file].end_with?('.yaml') 
+        File.write(options[:deploy_file], deployment.to_yaml)
+      end
+
       deployment
     end
   end
@@ -37,25 +42,33 @@ module DanarchyDeploy
   class RemoteDeploy
     def self.new(deployment, options)
       puts "\n" + self.name
+
       options[:working_dir] = options[:deploy_dir] + '/' + deployment[:hostname]
       connector = { hostname: deployment[:hostname],
                     ipv4:     deployment[:ipv4],
                     ssh_user: deployment[:ssh_user],
                     ssh_key:  deployment[:ssh_key] }
 
-      install_gem(connector, options)
-      push_deployment(connector, options)
-      deploy_result = remote_LocalDeploy(connector, options)
+      remote_mkdir(connector, options)
 
-      if deploy_result[:stderr]
-        puts '   ! Deployment failed!'
-        abort("STDERR:\n#{deploy_result[:stderr]}")
+      if options[:dev_gem]
+        puts "\nDev Gem mode: Building and pushing gem..."
+        gem = dev_gem_build(options)
+        dev_gem_install(connector, gem, options)
       else
-        puts deploy_result[:stdout]
+        gem_install(connector, options)
       end
 
-      pull_deployment(connector, options)
-      remote_Cleanup(connector, options)
+      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_deployment(connector, options)
+      deploy_result = remote_LocalDeploy(connector, gem_binary, options)
+
+      abort("\n ! Deployment failed to complete!") if !deploy_result
+
+      pull_deployment(connector, options) if !options[:pretend]
+      # remote_cleanup(connector, options) if !options[:pretend]
 
       puts "\nRemote deployment complete!"
       deployment = JSON.parse(File.read(options[:deploy_file]), symbolize_names: true) if options[:deploy_file].end_with?('.json')
@@ -64,68 +77,186 @@ module DanarchyDeploy
     end
 
     private
-    def self.install_gem(connector, options)
+    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_result = DanarchyDeploy::Helpers.run_command(mkdir_cmd, options)
+
+      if mkdir_result[:stderr]
+        abort('   ! Directory creation failed!')
+      else
+        puts "   |+ Created directory: '#{options[:deploy_dir]}'"
+      end
+
+      puts "\n > Setting directory permissions to '0750' for '#{connector[:ssh_user]}' on '#{options[:deploy_dir]}'"
+      chown_cmd = _ssh_command(connector, "sudo chown -Rc #{connector[:ssh_user]}:#{connector[:ssh_user]} #{options[:deploy_dir]}; " +
+                                          "sudo chmod -c 0750 #{options[:deploy_dir]}")
+      chown_result = DanarchyDeploy::Helpers.run_command(chown_cmd, options)
+
+      if chown_result[:stderr]
+        abort('   ! Setting directory permissions failed!')
+      else
+        puts '   |+ Set directory permissions!'
+      end
+    end
+
+    def self.gem_install(connector, options)
       puts "\n > Installing danarchy_deploy on #{connector[:hostname]}"
-      install_result = DanarchyDeploy::Helpers.run_command("ssh -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]} -o ConnectTimeout=30 'sudo gem install -f danarchy_deploy && test -d #{options[:working_dir]} || sudo mkdir -vp #{options[:working_dir]} && sudo chown -Rc #{connector[:ssh_user]}:#{connector[:ssh_user]} #{options[:working_dir]}'", options)
+      install_cmd = _ssh_command(connector, 'sudo gem install -f danarchy_deploy')
+      install_result = DanarchyDeploy::Helpers.run_command(install_cmd, options)
 
       if install_result[:stderr]
-        puts '   ! Gem install failed!'
-        abort("STDERR:\n#{install_result[:stderr]}")
+        abort('   ! Gem install failed!')
       else
         puts "   |+ Gem installed!"
       end
     end
 
-    # Add ssh-keygen function, then update 
+    def self.dev_gem_build(options)
+      gem = "danarchy_deploy-#{DanarchyDeploy::VERSION}.gem"
+      puts "\n > Building gem: #{gem}"
+      gem_dir = File.expand_path('../../', __FILE__)
+
+      abort('ERROR: Need to be in development gem directory for --dev-gem!') if Dir.pwd != gem_dir
+      
+      gem_path = "#{gem_dir}/pkg/#{gem}"
+      build_cmd = "cd #{gem_dir} && git add . && rake build"
+      build_result = DanarchyDeploy::Helpers.run_command(build_cmd, options)
+
+      if build_result[:stderr]
+        abort('   ! Gem build failed!')
+      elsif File.exist?(gem_path)
+        puts "   |+ Gem built: #{gem_path}"
+      end
+
+      gem_path
+    end
+
+    def self.dev_gem_install(connector, gem, options)
+      puts "\n > Pushing gem: #{gem} to #{connector[:hostname]}"
+      push_cmd = _scp_push(connector, gem, options[:deploy_dir])
+      push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)
+
+      if push_result[:stderr]
+        abort('   ! Gem push failed!')
+      else
+        puts '   |+ Gem pushed!'
+      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_result = DanarchyDeploy::Helpers.run_command(install_cmd, options)
+
+      if install_result[:stderr]
+        abort('   ! Gem install failed!')
+      else
+        puts '   |+ Gem installed!'
+      end
+    end
+
+    def self.gem_clean(connector, options)
+      clean_cmd = _ssh_command(connector, 'sudo gem clean danarchy_deploy 2&>/dev/null')
+      system(clean_cmd)
+    end
+
+    def self.push_temmplates(connector, options)
+      template_dir = options[:deploy_dir] + '/templates'
+      puts "\n > Pushing templates: #{template_dir}"
+      push_cmd = _rsync_push(connector, template_dir, template_dir)
+      push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)
+      
+      if push_result[:stderr]
+        abort('   ! Templates push failed!')
+      else
+        puts "   |+ Templates pushed to '#{options[:working_dir]}'!"
+      end
+    end
+
     def self.push_deployment(connector, options)
       puts "\n > Pushing deployment: #{options[:deploy_file]}"
-      push_result = DanarchyDeploy::Helpers.run_command("rsync --rsh 'ssh -i #{connector[:ssh_key]}' -Havzu --delete #{options[:working_dir]}/ #{connector[:ssh_user]}@#{connector[:ipv4]}:#{options[:working_dir]}/", options)
-      # push_result = DanarchyDeploy::Helpers.run_command("scp -i #{connector[:ssh_key]} #{options[:deploy_file]} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{options[:deploy_dir]}/#{connector[:hostname]}/", options)
-      
+      push_cmd = _rsync_push(connector, options[:working_dir], options[:working_dir])
+      push_result = DanarchyDeploy::Helpers.run_command(push_cmd, options)
+
       if push_result[:stderr]
-        puts '   ! Deployment push failed!'
-        abort("STDERR:\n#{push_result[:stderr]}")
+        abort('   ! Deployment push failed!')
       else
-        puts "   |+ Deployment pushed!"
+        puts "   |+ Deployment pushed to '#{options[:working_dir]}'!"
       end
     end
 
-    def self.remote_LocalDeploy(connector, options)
-      puts "\n > Running LocalDeploy on #{connector[:hostname]}\n\tOutput will return at the end of deployment."
+    def self.remote_LocalDeploy(connector, gem_binary, options)
+      puts "\n > Running LocalDeploy on #{connector[:hostname]}.\n\n"
 
-      deployment =  "ssh -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]} 'sudo danarchy_deploy local "
-      deployment += '--first-run '   if options[:first_run]
-      deployment += '--ssh-verbose ' if options[:ssh_verbose]
-      deployment += '--pretend '     if options[:pretend]
-      deployment += '--json '        if options[:deploy_file].end_with?('.json')
-      deployment += '--yaml '        if options[:deploy_file].end_with?('.yaml')
-      deployment += options[:deploy_file] + '\''
+      deploy_cmd  = "sudo #{gem_binary} local "
+      deploy_cmd += '--first-run '    if options[:first_run]
+      deploy_cmd += '--ssh-verbose '  if options[:ssh_verbose]
+      deploy_cmd += '--vars-verbose ' if options[:vars_verbose]
+      deploy_cmd += '--pretend '      if options[:pretend]
+      deploy_cmd += '--json '         if options[:deploy_file].end_with?('.json')
+      deploy_cmd += '--yaml '         if options[:deploy_file].end_with?('.yaml')
+      deploy_cmd += options[:deploy_file]
 
-      DanarchyDeploy::Helpers.run_command(deployment, options)
+      deploy_command = _ssh_command(connector, deploy_cmd)
+      system(deploy_command)
     end
 
     def self.pull_deployment(connector, options)
       puts "\n > Pulling deployment: #{options[:deploy_file]}"
-      pull_result = DanarchyDeploy::Helpers.run_command("scp -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{options[:deploy_file]} #{options[:deploy_file]}", options)
+      pull_cmd = _scp_pull(connector, options[:deploy_file], options[:deploy_file])
+      pull_result = DanarchyDeploy::Helpers.run_command(pull_cmd, options)
       
       if pull_result[:stderr]
-        puts '   ! Deployment pull failed!'
-        abort("STDERR:\n#{pull_result[:stderr]}")
+        abort('   ! Deployment pull failed!')
       else
         puts "   |+ Deployment pulled!"
       end
     end
 
-    def self.remote_Cleanup(connector, options)
+    def self.remote_cleanup(connector, options)
       puts "\n > Cleaning up: #{options[:deploy_dir]}"
-      cleanup_result = DanarchyDeploy::Helpers.run_command("ssh -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]} 'sudo rm -rfv #{options[:working_dir]}'", options)
+      cleanup_cmd = _ssh_command(connector, "sudo rm -rfv #{options[:working_dir]}")
+      cleanup_result = DanarchyDeploy::Helpers.run_command(cleanup_cmd, options)
 
       if cleanup_result[:stderr]
-        puts '   ! Deployment cleanup failed!'
-        abort("STDERR:\n#{cleanup_result[:stderr]}")
+        abort('   ! Deployment cleanup failed!')
       else
         puts "   |+ Deployment cleaned up!"
       end
     end
+
+    def self._locate_gem_binary(connector, options)
+      locate_cmd = _ssh_command(connector, 'sudo which danarchy_deploy')
+      locate_result = DanarchyDeploy::Helpers.run_command(locate_cmd, options)
+
+      if locate_result[:stderr]
+        abort('   ! Could not locate Ruby gem binary!')
+      else
+        puts '   |+ Gem binary located!'
+      end
+
+      locate_result[:stdout].chomp
+    end
+
+    def self._ssh_command(connector, command)
+      "ssh -i #{connector[:ssh_key]} " +
+        "#{connector[:ssh_user]}@#{connector[:ipv4]} " +
+        "-o ConnectTimeout=30 -o StrictHostKeyChecking=no '#{command}'"
+    end
+
+    def self._scp_push(connector, local, remote)
+      "scp -i #{connector[:ssh_key]} #{local} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/"
+    end
+
+    def self._scp_pull(connector, remote, local)
+      "scp -i #{connector[:ssh_key]} #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote} #{local}"
+    end
+
+    def self._rsync_push(connector, local, remote)
+      "rsync --rsh 'ssh -i #{connector[:ssh_key]}' -Havzu --delete #{local}/ #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/"
+    end
+
+    def self._rsync_pull(connector, remote, local)
+      "rsync --rsh 'ssh -i #{connector[:ssh_key]}' -Havzu --delete #{connector[:ssh_user]}@#{connector[:ipv4]}:#{remote}/ #{local}/"
+    end
   end
 end