vagrant-communicator-docker 1.0.7

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eb4aea56e9f2b6c933234e8c76a9bde7721b897639ace97c9d8546d50343d2cd
+  data.tar.gz: d9bc70a8168645b609d1b5c9ba57e6059180d74969097f1b06bbf0e934741c4f
+SHA512:
+  metadata.gz: c55d121aca3d826ffbe5f1b6c053a23b3843183056f2e6d9e47755a661d00338c2e35dbb54cc7c21797cb1c6127d6eeb66670a1bb1b2cca807c5944d7477a1c0
+  data.tar.gz: bd23c04708f136e37381e0ad0d10b7fadf1013188879c94b4111cc83dfe896a690fe512fce035376b72f5136ac7207174f4842ff91db3bdca35792ae7f8e5dc8

data/.gitignore

@@ -0,0 +1,13 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/spec/reports/
+/tmp/
+/vendor
+/vagrant-communicator-docker
+/bin
+/pkg
+Gemfile.lock
+

data/Gemfile

@@ -0,0 +1,10 @@
+source "https://rubygems.org"
+gem 'docker-api'
+
+group :development do
+  gem "vagrant", git: "https://github.com/hashicorp/vagrant.git"
+end
+
+group :plugins do
+  gem "communicator-docker", path: "."
+end

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2019 Lucas van Staden
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,114 @@
+# Vagrant::Communicator::Docker
+
+This is a communicator plugin allowing vagrant to access docker instances as if they have SSH.
+
+This was created to facilitate host file management using a vagrant host file manager plugin, which requires SSH to fetch, 
+edit, and put back container hosts files. The assumption that vagrant SSH communicator makes, is that all containers
+have SSH - They do not.
+
+This communicator will make vagrant tasks that require SSH, interact with the docker instances, as if SSH exists, by 
+using the Docker API.
+
+This has only been used in a Linux environment.
+
+## Requirements
+
+* Docker API gem: ```vagrant plugin install docker-api```
+
+If you get an error noted as: ```undefined method `copy' for...``` please use : ```vagrant plugin install docker-api --plugin-version=1.34.2```
+
+## Installation
+
+Needs to be installed as a vagrant plugin
+
+```
+vagrant plugin install vagrant-communicator-docker
+```
+
+### Manual install
+
+* fetch the built gem package located here: ```https://raw.githubusercontent.com/ProxiBlue/vagrant-communicator-docker/master/communicator-docker-1.0.6.gem```
+* install using: ```vagrant plugin install communicator-docker-1.0.6.gem```
+
+```
+curl https://raw.githubusercontent.com/ProxiBlue/vagrant-communicator-docker/master/communicator-docker-1.0.6.gem > communicator-docker-1.0.6.gem
+```
+
+## Usage
+
+* You need to set your vagrant instance to have SSH using ```has_ssh```
+* You need to set the communicator using ```vm.communicator = 'docker'```
+* You can set the shell to use with ```vm.communicator.bash_shell```
+* You can set the shell wait with ```vm.communicator.bash_wait```
+
+Example vagrant definition:
+
+```
+config.vm.define "database", primary: false do |database|
+        database.hostmanager.aliases = [ "database."+dev_domain ]
+        database.vm.network :private_network, ip: "172.20.0.208", subnet: "172.20.0.0/16"
+        database.vm.hostname = "database"
+        database.vm.communicator = 'docker'
+        database.vm.provider 'docker' do |d|
+            d.image = "mysql:5.7"
+            d.has_ssh = true
+            d.name = "database"
+            d.remains_running = true
+        end
+    end
+```
+
+## Limitations
+
+Communicates with a local docker service via linux sockets. That is all I need.
+Should be able to be extended to include a docker connection string to a tcp connection, but I have no need for that as yet, so not implemented.
+
+The default shell will be /bin/bash inside the docker container. You can override this using : ```vm.communicator.bash_shell = '/bin/sh';``` to use /bin/sh (or any other shell)
+
+If you get the error:
+
+```
+The guest operating system of the machine could not be detected!
+Vagrant requires this knowledge to perform specific tasks such
+as mounting shared folders and configuring networks. Please add
+the ability to detect this guest operating system to Vagrant
+by creating a plugin or reporting a bug.
+
+```
+
+you likely need to change the shell to /bin/sh OR increase the shell_wait (default is 10)
+
+## shell_wait
+
+I have found some docker instances need a little extra time to initialise, before docker can send commands
+The default wait timeout is 10s. Increase in increments of 5 to see if you can overcome issue.
+
+## Solved issues?
+
+Not had this for some time, so I think solved due to ongoing changes.
+
+### Problems with some docker images, failing with message that image is not running
+
+I have not managed to spend time on this, to pin it down, but some (random) docker images will fail if you set ```d.has_ssh = true``` - The only fix is to set that to false, which can stop other functions (example usage of a hostmanager plugin)
+
+You can run a global trigger to overcome this, allowing hostmanagers to update after it was completed:
+
+```
+config.trigger.after :up do |trigger|
+   trigger.run = {inline: "bash -c 'vagrant hostmanager --provider docker'"}
+end
+```
+
+## Debug
+
+```vagrant halt database && vagrant up database --debug &>/tmp/debug.log``` then view the debug log.
+
+You will see debug entries with the string: ```DOCKER COMMUNICATOR``` 
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/ProxiBlue/vagrant-communicator-docker.
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,3 @@
+require "rubygems"
+require "bundler/setup"
+Bundler::GemHelper.install_tasks

data/communicator-docker.gemspec

@@ -0,0 +1,16 @@
+require File.expand_path('../lib/vagrant-communicator-docker/version', __FILE__)
+
+Gem::Specification.new do |s|
+  s.name            = 'vagrant-communicator-docker'
+  s.version         = VagrantPlugins::VagrantCommunicatorDocker::VERSION
+  s.date            = '2019-11-01'
+  s.summary         = "Simulate SSH using Docket API when provisioning vagrant machines that use docker images without SSH"
+  s.description     = "Simulate SSH using Docket API when provisioning vagrant machines that use docker images without SSH"
+  s.authors         = ["Lucas van Staden"]
+  s.email           = 'sales@proxiblue.com.au'
+  s.files           = `git ls-files`.split($\)
+  s.executables     = s.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  s.require_paths   = ['lib']
+  s.homepage        = 'https://github.com/ProxiBlue/vagrant-communicator-docker'
+  s.license         = 'MIT'
+end

data/lib/vagrant-communicator-docker/config.rb

@@ -0,0 +1,19 @@
+module VagrantPlugins
+  module VagrantCommunicatorDocker
+    class Config < Vagrant.plugin('2', :config)
+      attr_accessor :bash_shell
+      attr_accessor :bash_wait
+
+      def initialize
+        @bash_shell         = UNSET_VALUE
+        @bash_wait         = UNSET_VALUE
+      end
+
+      def finalize!
+        @bash_shell         = '/bin/bash' if @bash_shell == UNSET_VALUE
+        @bash_wait         = 10 if @bash_wait == UNSET_VALUE
+      end
+
+    end
+  end
+end

data/lib/vagrant-communicator-docker/plugin.rb

@@ -0,0 +1,29 @@
+
+
+begin
+  require "vagrant"
+rescue LoadError
+  raise "The Vagrant AWS plugin must be run within Vagrant."
+end
+
+module VagrantPlugins
+  module VagrantCommunicatorDocker
+    class Plugin < Vagrant.plugin("2")
+      name "Docker Communicator"
+      description <<-DESC
+      This plugin allows Vagrant to communicate with docker instances that do not have SSH,
+      but can use docker exec to run commands within
+      DESC
+
+      communicator("docker") do
+        require File.expand_path("../vagrant-communicator-docker", __FILE__)
+        Communicator
+      end
+
+      config("communicator") do
+        require_relative "config"
+        Config
+      end
+    end
+  end
+end

data/lib/vagrant-communicator-docker/vagrant-communicator-docker.rb

@@ -0,0 +1,157 @@
+require 'logger'
+require 'timeout'
+require 'rubygems/package'
+require 'fileutils'
+
+require 'log4r'
+require 'docker'
+
+module VagrantPlugins
+  module VagrantCommunicatorDocker
+    # This class provides communication with Docker instances
+    class Communicator < Vagrant.plugin("2", :communicator)
+
+      def self.match?(machine)
+        # All machines are currently expected to be docker instances.
+        return true
+      end
+
+      def initialize(machine)
+        @logger  = Log4r::Logger.new("vagrant::communication::docker")
+        @machine = machine
+        @machineID = machine.id
+        @logger.debug("MACHINE ID #{@machineID}")
+        @logger.debug("MACHINE SHELL: #{@machine.config.communicator.bash_shell}")
+        @logger.debug("SHELL WAIT: #{@machine.config.communicator.bash_wait}")
+      end
+
+      def ready?
+        begin
+            @logger.info(Docker.version)
+            @container = Docker::Container.get(@machineID)
+            @logger.debug(@container.json)
+            # If we reached this point then we successfully connected
+            true
+        rescue
+            @logger.debug("DOCKER COMMUNICATOR - Could not make connection to #{@machineID}")
+            false
+        end
+      end
+
+      # wait_for_ready waits until the communicator is ready, blocking
+      # until then. It will wait up to the given duration or raise an
+      # exception if something goes wrong.
+      #
+      # @param [Integer] duration Timeout in seconds.
+      # @return [Boolean] Will return true on successful connection
+      #   or false on timeout.
+      def wait_for_ready(duration)
+        # By default, we implement a naive solution.
+        begin
+          Timeout.timeout(duration) do
+            while true
+              return true if ready?
+              sleep 0.5
+            end
+          end
+        rescue Timeout::Error
+          # We timed out, we failed.
+        end
+
+        return false
+      end
+
+      # Download a file from the remote machine to the local machine.
+      #
+      # @param [String] from Path of the file on the remote machine.
+      # @param [String] to Path of where to save the file locally.
+      def download(from, to)
+        @logger.debug("DOCKER COMMUNICATOR - DOWNLOAD from: #{from} to: #{to}")
+        tempfile = "/tmp/#{SecureRandom.urlsafe_base64}.tar"
+        @logger.debug("DOCKER COMMUNICATOR - tempfile - #{tempfile}")
+        File.open(tempfile, "w") do |file|
+            @container.archive_out(from) do |chunk|
+                file.write(chunk)
+            end
+        end
+        Gem::Package::TarReader.new( File.open(tempfile) ) do |tar|
+            tar.each do |entry|
+                File.open to, "wb" do |f|
+                    f.print entry.read
+                end
+            end
+        end
+      end
+
+      # Upload a file to the remote machine.
+      #
+      # @param [String] from Path of the file locally to upload.
+      # @param [String] to Path of where to save the file on the remote
+      #   machine.
+      def upload(from, to)
+        @logger.debug("DOCKER COMMUNICATOR - upload from: #{from} to: #{to}")
+        @container.archive_in(from, File.dirname(to), overwrite: true)
+      end
+
+      # Execute a command on the remote machine. The exact semantics
+      # of this method are up to the implementor, but in general the
+      # users of this class will expect this to be a shell.
+      #
+      # This method gives you no way to write data back to the remote
+      # machine, so only execute commands that don't expect input.
+      #
+      # @param [String] command Command to execute.
+      # @yield [type, data] Realtime output of the command being executed.
+      # @yieldparam [String] type Type of the output. This can be
+      #   `:stdout`, `:stderr`, etc. The exact types are up to the
+      #   implementor.
+      # @yieldparam [String] data Data for the given output.
+      # @return [Integer] Exit code of the command.
+      def execute(command, opts=nil)
+        begin
+            wait_for_ready(@machine.config.communicator.bash_wait)
+            result = @container.exec([@machine.config.communicator.bash_shell, '-c' , command], stderr: false)
+            @logger.debug(result)
+            @logger.debug(result.last)
+            return result.last
+        rescue
+            @logger.info("Error running command " + command + " on guest using shell #{@machine.config.communicator.bash_shell}")
+        end
+        return 255
+      end
+
+      # Executes a command on the remote machine with administrative
+      # privileges. See {#execute} for documentation, as the API is the
+      # same.
+      #
+      # @see #execute
+      def sudo(command, opts=nil)
+        @logger.debug("DOCKER COMMUNICATOR - EXECUTE WITH SUDO: #{command}")
+        execute(command, opts)
+      end
+
+      # Executes a command and returns true if the command succeeded,
+      # and false otherwise. By default, this executes as a normal user,
+      # and it is up to the communicator implementation if they expose an
+      # option for running tests as an administrator.
+      #
+      # @see #execute
+      def test(command, opts=nil)
+        result = execute(command, opts)
+        if result == 0
+            return true
+        end
+        return false
+      end
+
+       # Reset the communicator. For communicators which establish
+      # a persistent connection to the remote machine, this connection
+      # should be terminated and re-established. The communicator
+      # instance should be in a "fresh" state after calling this method.
+      def reset!
+         @logger.debug("DOCKER COMMUNICATOR - RESET - NOT IMPLEMENTED")
+      end
+
+    end
+  end
+end

data/lib/vagrant-communicator-docker/version.rb

@@ -0,0 +1,5 @@
+module VagrantPlugins
+  module VagrantCommunicatorDocker
+      VERSION = '1.0.7'
+  end
+end

data/lib/vagrant-communicator-docker.rb

@@ -0,0 +1,2 @@
+require 'vagrant-communicator-docker/plugin'
+

data/package-lock.json

@@ -0,0 +1,3 @@
+{
+  "lockfileVersion": 1
+}

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: vagrant-communicator-docker
+version: !ruby/object:Gem::Version
+  version: 1.0.7
+platform: ruby
+authors:
+- Lucas van Staden
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-11-01 00:00:00.000000000 Z
+dependencies: []
+description: Simulate SSH using Docket API when provisioning vagrant machines that
+  use docker images without SSH
+email: sales@proxiblue.com.au
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- communicator-docker-0.0.1.gem
+- communicator-docker-1.0.0.gem
+- communicator-docker-1.0.1.gem
+- communicator-docker-1.0.2.gem
+- communicator-docker-1.0.3.gem
+- communicator-docker-1.0.4.gem
+- communicator-docker-1.0.5.gem
+- communicator-docker-1.0.6.gem
+- communicator-docker.gemspec
+- lib/vagrant-communicator-docker.rb
+- lib/vagrant-communicator-docker/config.rb
+- lib/vagrant-communicator-docker/plugin.rb
+- lib/vagrant-communicator-docker/vagrant-communicator-docker.rb
+- lib/vagrant-communicator-docker/version.rb
+- package-lock.json
+homepage: https://github.com/ProxiBlue/vagrant-communicator-docker
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.1.2
+signing_key: 
+specification_version: 4
+summary: Simulate SSH using Docket API when provisioning vagrant machines that use
+  docker images without SSH
+test_files: []