machine_configure 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 1ccd8db9cf4911d7c39b8a1a60e2aef90f38798437bcb1e6f463c9977fcc369f
+  data.tar.gz: 073d2219e21ec95877111f79cc430da279dd1fb8551e94f82f072d3478fc8d6e
+SHA512:
+  metadata.gz: 6a9ef77ddcef9d115d2e796fe0493a4f1623ac65adb5e46dac1f7f138a23bc5c8b24e66060c682041b11414d3aea6236d8eff298b89b66332dbf5ec5dc82fc9a
+  data.tar.gz: 3ea90114839e8c543de8ee78678a0e97d8e8e3384cdc5970ea636a1ad90888775b52c8d46a588b791c48cd4214374c48657e0af51d0b885cf0abd0ce1335af3c

data/.gitignore

@@ -0,0 +1,11 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+
+.byebug_history
+.virb/

data/.travis.yml

@@ -0,0 +1,5 @@
+sudo: false
+language: ruby
+rvm:
+  - 2.5.1
+before_install: gem install bundler -v 1.16.2

data/Gemfile

@@ -0,0 +1,7 @@
+source 'https://rubygems.org'
+
+git_source(:github) { |repo_name| "https://github.com/#{repo_name}" }
+
+gem 'argument_parser', git: 'https://github.com/Noah2610/ArgumentParser'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,33 @@
+GIT
+  remote: https://github.com/Noah2610/ArgumentParser
+  revision: 3ac5b0083fd42ae8740d1d22d988f56c74a29470
+  specs:
+    argument_parser (1.0.0)
+
+PATH
+  remote: .
+  specs:
+    machine_configure (0.0.1)
+      rubyzip (~> 1.2)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    minitest (5.11.3)
+    rake (10.5.0)
+    rdoc (6.0.4)
+    rubyzip (1.2.1)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  argument_parser!
+  bundler (~> 1.16)
+  machine_configure!
+  minitest (~> 5.0)
+  rake (~> 10.0)
+  rdoc
+
+BUNDLED WITH
+   1.16.3

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Noah Rosenzweig
+
+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,100 @@
+# MachineConfigure
+Export or import your docker-machine's configuration files,  
+and share them with others.
+
+## Table of Contents _(Generated)_
+- [Description](#description)
+- [Installation](#installation)
+  - [Install manually](#install-manually)
+- [Usage](#usage)
+  - [Exporting](#exporting)
+    - [Example](#example)
+  - [Importing](#importing)
+    - [Example](#example)
+- [TODO](#todo)
+- [License](#license)
+
+## Description
+This gem is heavily inspired by [machine-share][machine-share-site],  
+a nodejs package, which does basically the same thing as this gem.  
+I just had some minor inconveniences with it,  
+so I decided I would write my own version in Ruby.
+
+If you use [docker-machine][docker-machine-site], this might come in handy,  
+if you ever want to share your remote docker-machine instance  
+with a collegue or across multiple machines.
+
+With this gem, you can export your configuration files for a specific  
+docker-machine instance into a zip file. You can then share the created  
+zip file with others / other computers and import it again.
+
+## Installation
+__ATTENTION:  
+The gem is not yet available on rubygems.org, this is still a todo.__
+
+Install from [rubygems][rubygems-site] with ...
+
+```
+$ gem install machine_configure
+```
+
+### Install manually
+If you want to install the gem manually from this repository directly,  
+you'll need to:
+
+- Clone the repository,
+- install all dependencies,
+- build the gem, and
+- install it.
+
+Here's a command to copy/paste, it does all of the above ...
+
+```
+git clone https://github.com/Noah2610/MachineConfigure.git && \
+cd MachineConfigure && \
+bundle install --with development && \
+rake build && \
+gems=($(ls pkg/machine_configure-*)); \
+gem install "${gems[-1]}"; \
+unset gems
+```
+
+Once this completes, you should have the gem installed.  
+You can try using it by executing `maccon`.
+
+## Usage
+### Exporting
+To export the configurations of an existing docker-machine instance,  
+use the `export` keyword, pass the machine's name,  
+and optionally, the output zip file.
+#### Example
+
+```
+$ maccon export my_machine                         # Creates my_machine.zip
+$ maccon export my_machine my_machine_configs.zip  # Creates my_machine_configs.zip
+```
+
+### Importing
+To import a docker-machine's configuration files from a zip file,  
+use the `import` keyword, and pass the target zip file.
+#### Example
+
+```
+$ maccon import my_machine_configs.zip
+```
+
+For all command-line options, see `--help`.
+
+---
+
+## TODO
+See the [Trello Board][trello-site] for open tasks.
+
+## License
+The gem is available as open source under the terms of the [MIT License][mit-site].
+
+[machine-share-site]:  https://github.com/bhurlow/machine-share
+[docker-machine-site]: https://docs.docker.com/machine
+[rubygems-site]:       https://rubygems.org/gems/machine_configure
+[trello-site]:         https://trello.com/b/ZVdArdrk
+[mit-site]:            https://opensource.org/licenses/MIT

data/Rakefile

@@ -0,0 +1,10 @@
+require "bundler/gem_tasks"
+require "rake/testtask"
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/**/*_test.rb"]
+end
+
+task :default => :test

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'machine_configure'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require 'pry'
+# Pry.start
+
+require 'irb'
+IRB.start(__FILE__)

data/bin/rdoc

@@ -0,0 +1,9 @@
+#!/bin/bash
+# Generate rdoc documentation
+
+root="$( dirname "$0" )/.."
+dir="${root}/lib"
+main="${dir}/machine_configure.rb"
+output_dir="${root}/doc"
+
+rdoc --main "$main" --op "$output_dir" $dir

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/maccon

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'machine_configure'
+
+cli = MachineConfigure::CLI.new
+cli.run

data/lib/machine_configure/cli.rb

@@ -0,0 +1,92 @@
+module MachineConfigure
+  class CLI
+    include Helpers::Message
+    include CLIConstants
+
+    def initialize
+      Helpers::Message.error_no_stack_trace!
+      @arguments = nil
+    end
+
+    # Parses given command-line arguments,
+    # and sets proper settings.
+    def run
+      @arguments = ArgumentParser.get_arguments VALID_ARGUMENTS
+      print_help     if (@arguments[:options][:help])
+      print_version  if (@arguments[:options][:version])
+      if    (@arguments[:keywords][:export])
+        handle_export
+      elsif (@arguments[:keywords][:import])
+        handle_import
+      else
+        print_help
+      end
+    end
+
+    private
+
+      def print_help
+        puts HELP_TEXT
+        exit
+      end
+
+      def print_version
+        puts "#{GEM_NAME} v#{VERSION}"
+        exit
+      end
+
+      def handle_export
+        verify_keywords_export
+        dm_name = @arguments[:keywords][:export][1]
+        zipfile = @arguments[:keywords][:export][2]
+        zipfile = get_zipfile_from_name dm_name  unless (zipfile)
+        exporter = Exporter.new dm_name
+        exporter.export_to zipfile
+      end
+
+      def handle_import
+        verify_keywords_import
+        zipfile = @arguments[:keywords][:import][1]
+        importer = Importer.new
+        importer.import_from zipfile
+      end
+
+      def verify_options *option_names
+        option_names.flatten.each do |option_name|
+          error(
+            "Option `--#{VALID_ARGUMENTS[:double][option_name].first.first}' must be given."
+          )  unless (@arguments[:options][option_name])
+        end
+      end
+
+      def verify_keywords_export
+        error(
+          "Missing argument DOCKER_MACHINE_NAME for #{VALID_ARGUMENTS[:keywords][:export].first.first}."
+        )  unless (@arguments[:keywords][:export][1])
+        verify_keyword_size_for :export
+      end
+
+      def verify_keywords_import
+        error(
+          "Missing argument ZIP_FILE for #{VALID_ARGUMENTS[:keywords][:import].first.first}.",
+          "See --help for more information."
+        )  unless (@arguments[:keywords][:import][1])
+        verify_keyword_size_for :import
+      end
+
+      def verify_keyword_size_for keyword_name
+        target_size = VALID_ARGUMENTS[:keywords][keyword_name].size
+        given_size  = @arguments[:keywords][keyword_name].size
+        if (given_size > target_size)
+          extra_arguments = @arguments[:keywords][keyword_name][target_size .. -1]
+          error(
+            "Invalid argument#{extra_arguments.size > 1 ? ?s : ''} `#{extra_arguments.join(', ')}'"
+          )
+        end
+      end
+
+      def get_zipfile_from_name dm_name
+        return "#{dm_name}.zip"
+      end
+  end
+end

data/lib/machine_configure/cli_constants.rb

@@ -0,0 +1,81 @@
+module MachineConfigure
+  module CLIConstants
+    # Hash containing all valid arguments,
+    # which may be passed to the CLI.
+    VALID_ARGUMENTS = {
+      single: {
+        help: [
+          [?h],
+          false
+        ],
+        version: [
+          [?v],
+          false
+        ],
+        name: [
+          [?n],
+          true
+        ],
+        zipfile: [
+          [?z],
+          true
+        ]
+      },
+      double: {
+        help: [
+          ['help'],
+          false
+        ],
+        version: [
+          ['version'],
+          false
+        ],
+        name: [
+          ['name'],
+          true
+        ],
+        zipfile: [
+          ['zip'],
+          true
+        ]
+      },
+      keywords: {
+        export: [['export', ?e], :INPUT, :INPUTS],
+        import: [['import', ?i], :INPUTS]
+      }
+    }
+
+    # The <tt>--help</tt> text.
+    cli_name = DIR[:caller].basename
+    HELP_TEXT = <<-END_HELP_TEXT
+USAGE
+  $ #{cli_name} [--help|--version]
+  $ #{cli_name} export DOCKER_MACHINE_NAME [ZIP_FILE]
+  $ #{cli_name} import ZIP_FILE
+
+KEYWORDS
+  export
+    Export existing configuration files from
+    the docker-machine instance DOCKER_MACHINE_NAME.
+    Optionally, add a ZIP_FILE name.
+  import
+    Import an exported ZIP_FILE.
+
+OPTIONS
+  --help -h
+    Print this text and exit.
+  --version -v
+    Print the current version number and exit.
+
+EXAMPLES
+  Export an existing docker-machine instance with the name "my_machine",
+  to a new zip file "my_machine.zip":
+    $ #{cli_name} export my_machine
+  The same as above, but specify the output zip file name:
+    $ #{cli_name} export my_machine my_machine_configs
+  Import a new docker-machine instance from
+  the zip file "my_machine_configs.zip":
+    $ #{cli_name} import my_machine_configs.zip
+    END_HELP_TEXT
+  end
+end

data/lib/machine_configure/exporter.rb

@@ -0,0 +1,84 @@
+module MachineConfigure
+  # The Exporter is responsible for finding all
+  # necessary certificates for a given docker-machine,
+  # and bundle them all into a single zip archive.
+  class Exporter
+    include Helpers::Message
+    include Helpers::Shared
+
+    # Initialize with a docker-machine <tt>name</tt>.
+    def initialize name
+      @machine_name = name
+      VALIDATOR.validate_machine_name name
+      @dir = {
+        machine: DM_MACHINES_PATH.join(@machine_name),
+        certs:   DM_CERTS_PATH.join(@machine_name)
+      }
+      VALIDATOR.validate_directories @dir[:machine]
+      @contents = nil
+    end
+
+    # Export certificates for the machine.
+    def export_to zip_file
+      zip_file = Pathname.new "#{zip_file.to_s}#{zip_file.to_s.match(/\.zip\z/i) ? '' : '.zip'}"
+      VALIDATOR.validate_zip_file_export zip_file
+      files     = get_files
+      @contents = get_contents_from_files(*files)
+      config_json_path = get_config_json_path
+      @contents[config_json_path] = remove_home_in @contents[config_json_path]
+      @contents[MACHINE_NAME_FILENAME] = @machine_name
+      write_zip_file_to zip_file
+      message(
+        "Successfully created zip archive",
+        "  `#{zip_file.to_s}'",
+        "with the keys and certificates from docker-machine",
+        "  `#{@machine_name}'"
+      )
+    end
+
+    private
+
+      # Returns all necessary filepaths.
+      def get_files
+        return @dir.values.map do |dir|
+          next get_files_recursively_from dir
+        end .reject { |x| !x } .flatten
+      end
+
+      # Returns all filepaths from <tt>directory</tt>, recursively.
+      def get_files_recursively_from directory
+        dir = Pathname.new directory
+        return nil  unless (dir.directory?)
+        return dir.each_child.map do |file|
+          next file.realpath.to_path            if (file.file?)
+          next get_files_recursively_from file  if (file.directory?)
+        end .flatten
+      end
+
+      # Reads contents from <tt>files</tt>, and returns
+      # a Hash with the file's filepath as the key and
+      # the file's content as the value.
+      # The filepath key is the absolute path to the file,
+      # but _without_ the DM_STORAGE_PATH.
+      def get_contents_from_files *files
+        return files.flatten.map do |filename|
+          file    = Pathname.new filename
+          content = file.read
+          path    = remove_storage_path_from file.to_path
+          next [path, content]
+        end .to_h
+      end
+
+      # Write the processed <tt>@contents</tt> to
+      # a zip archive using Zip.
+      def write_zip_file_to zip_file
+        Zip::File.open(zip_file, Zip::File::CREATE) do |zip|
+          @contents.each do |filepath, content|
+            zip.get_output_stream(filepath) do |zipfile|
+              zipfile.write content
+            end
+          end
+        end
+      end
+  end
+end

data/lib/machine_configure/helpers/message.rb

@@ -0,0 +1,77 @@
+module MachineConfigure
+  module Helpers
+    # This helper provides useful error methods,
+    # which may abort the script with an error message
+    # and a stack traceback.
+    module Message
+      MESSAGE_PADDING      = '  '
+      STACK_TRACE_SIZE     = 20
+      STACK_TRACE_PADDING  = 1
+      @@_error_stack_trace = true
+
+      class << self
+        # Disable stack trace output on #error method.
+        def error_no_stack_trace!
+          @@_error_stack_trace = false
+        end
+
+        # Enable stack trace output on #error method,
+        # if it was disabled.
+        def error_yes_stack_trace!
+          @@_error_stack_trace = true
+        end
+      end
+
+      private
+
+        def error *messages  #:doc:
+          message = messages.flatten.join(?\n).gsub(/^/, MESSAGE_PADDING)
+          output = [
+            "#{_get_message_header} ERROR:",
+            message,
+            "#{MESSAGE_PADDING}Exiting."
+          ]
+          if (@@_error_stack_trace)
+            stack_trace = caller[STACK_TRACE_PADDING ... (STACK_TRACE_SIZE + STACK_TRACE_PADDING)].map do |line|
+              next "#{MESSAGE_PADDING}#{line}"
+            end .reverse
+            output.unshift([
+              "Stack traceback (most recent call last):",
+              stack_trace,
+            ])
+          end
+          abort output.flatten.join(?\n)
+        end
+
+        def warning *messages  #:doc:
+          message = _get_warning_message_from(*messages.flatten)
+          puts message
+        end
+
+        def warning_print *messages  #:doc:
+          message = _get_warning_message_from(*messages.flatten)
+          print message
+        end
+
+        def message *messages  #:doc:
+          message = messages.flatten.join(?\n).gsub(/^/, MESSAGE_PADDING)
+          puts([
+            "#{_get_message_header}",
+            message
+          ].flatten.join(?\n))
+        end
+
+        def _get_warning_message_from *messages
+          message = messages.flatten.join(?\n).gsub(/^/, MESSAGE_PADDING)
+          return [
+            "#{_get_message_header} WARNING:",
+            message
+          ].flatten.join(?\n)
+        end
+
+        def _get_message_header
+          return DIR[:caller].basename
+        end
+    end
+  end
+end

data/lib/machine_configure/helpers/shared.rb

@@ -0,0 +1,31 @@
+module MachineConfigure
+  module Helpers
+    module Shared
+      private
+
+        # Returns the path to the docker-machine's <tt>'config.json'</tt> file,
+        # but without the prefixed path leading to the DM_MACHINES_PATH.
+        def get_config_json_path
+          return nil  unless (@machine_name)
+          config_json_path = remove_storage_path_from DM_MACHINES_PATH.join(@machine_name, 'config.json').to_path
+        end
+
+        # Returns the <tt>filepath</tt> without DM_STORAGE_PATH.
+        def remove_storage_path_from filepath
+          return filepath.to_s.sub("#{DM_STORAGE_PATH.to_path}/", '')
+        end
+
+        # Replaces any occurences of the user's
+        # home directory path with HOME_REPLACE_STRING.
+        def remove_home_in string
+          return string.gsub(HOME, HOME_REPLACE_STRING)
+        end
+
+        # Replaces any occurences of HOME_REPLACE_STRING
+        # with the user's home directory path.
+        def insert_home_in string
+          return string.gsub(HOME_REPLACE_STRING, HOME)
+        end
+    end
+  end
+end

data/lib/machine_configure/importer.rb

@@ -0,0 +1,71 @@
+module MachineConfigure
+  # The Importer takes a zip file,
+  # processes the files,
+  # and extracts them into the proper directories.
+  class Importer
+    include Helpers::Message
+    include Helpers::Shared
+
+    def initialize
+      @contents     = nil
+      @machine_name = nil
+    end
+
+    # Import given <tt>zip_file</tt>
+    # as a new docker-machine.
+    def import_from zip_file
+      VALIDATOR.validate_zip_file_import zip_file
+      @contents     = get_contents_from_zip zip_file
+      @machine_name = @contents[MACHINE_NAME_FILENAME]
+      @contents.delete MACHINE_NAME_FILENAME
+      @dir = {
+        machine: DM_MACHINES_PATH.join(@machine_name),
+        certs:   DM_CERTS_PATH.join(@machine_name)
+      }
+      #VALIDATOR.validate_directories_dont_exist *@dir.values
+      VALIDATOR.validate_no_machine_name @machine_name
+      config_json_path = get_config_json_path
+      @contents[config_json_path] = insert_home_in @contents[config_json_path]
+      write_contents
+      # Finally, check that the newly imported machine is recognized by docker-machine.
+      VALIDATOR.validate_machine_name @machine_name
+      message(
+        "Successfully imported docker-machine configuration files from archive",
+        "  `#{zip_file.to_s}'",
+        "for docker-machine",
+        "  `#{@machine_name}'"
+      )
+    end
+
+    private
+
+      # Reads the <tt>zip_file</tt> and returns
+      # a Hash with each file's path as the key
+      # and the file's content as the value.
+      def get_contents_from_zip zip_file
+        contents = {}
+        Zip::File.open(zip_file) do |zip|
+          zip.each_entry do |entry|
+            entry.get_input_stream do |entryfile|
+              contents[entry.name] = entryfile.read
+            end
+          end
+        end
+        return contents
+      end
+
+      # Write <tt>@contents</tt> to proper paths.
+      def write_contents
+        @contents.each do |relative_filepath, content|
+          filepath = DM_STORAGE_PATH.join relative_filepath
+          filedir  = filepath.dirname
+          filedir.mkpath     unless (filedir.directory?)
+          permission = 0644
+          permission = 0600  if (filepath.basename.to_path == 'id_rsa')
+          file = File.open filepath.to_path, ?w, permission
+          file.write content
+          file.close
+        end
+      end
+  end
+end

data/lib/machine_configure/meta.rb

@@ -0,0 +1,4 @@
+module MachineConfigure
+  GEM_NAME = 'machine_configure'
+  VERSION  = '0.0.1'
+end

data/lib/machine_configure/validator.rb

@@ -0,0 +1,220 @@
+module MachineConfigure
+  # This class should validate that dependencies are installed (docker-machine).
+  class Validator
+    include Helpers::Message
+    # Default command-line apps,
+    # which need to be available.
+    BASE_APPS = [
+      'docker-machine'
+    ]
+
+    def initialize
+      @validated_apps = []
+    end
+
+    # Calls #validate_apps for BASE_APPS.
+    def validate_base_apps
+      validate_apps *BASE_APPS
+    end
+
+    # Check if given <tt>apps</tt> (or default BASE_APPS),
+    # are available from the command-line.
+    # Throw an error and exit if any aren't available.
+    def validate_apps *apps
+      apps.flatten.each do |appname|
+        validate_app appname
+      end
+    end
+
+    # Check that the given <tt>name</tt>
+    # exists for docker-machine.
+    def validate_machine_name name
+      validate_app 'docker-machine'
+      error(
+        "Docker machine `#{name}' is not available."
+      )  unless (docker_machine_exists? name)
+    end
+
+    # Check that the given <tt>name</tt>
+    # does _not_ exist for docker-machine.
+    def validate_no_machine_name name
+      validate_app 'docker-machine'
+      prompt_to_replace_docker_machine name  if (docker_machine_exists? name)
+    end
+
+    # Check that the given <tt>directories</tt> exist,
+    # and are directories.
+    def validate_directories *directories
+      directories.flatten.each do |directory|
+        validate_directory directory
+      end
+    end
+
+    # Check that the given <tt>directories</tt> do *NOT* exist.
+    def validate_directories_dont_exist *directories
+      directories.flatten.each do |directory|
+        validate_directory_doesnt_exist directory
+      end
+    end
+
+    # Check that the given <tt>zip_file</tt>
+    # doesn't exist already but that the path leading
+    # to the file does exist.
+    def validate_zip_file_export zip_file
+      path = File.dirname zip_file
+      error(
+        "The path to the zip file `#{path.to_path}' doesn't exist."
+      )  unless (is_directory? path)
+      prompt_to_replace_file zip_file  if (is_file? zip_file)
+    end
+
+    # Similar to #validate_zip_file_export,
+    # but don't prompt for overwriting, etc.
+    # The zip file _has_ to exist in this case.
+    def validate_zip_file_import zip_file
+      error(
+        "The zip file `#{zip_file.to_s}' doesn't exist or is a directory."
+      )  unless (is_file? zip_file)
+    end
+
+    private
+
+      def validate_app appname
+        return  if (@validated_apps.include? appname)
+        if (app_available? appname)
+          @validated_apps << appname
+          return
+        end
+        error(
+          "`#{appname}' is not available.",
+          "Please make sure you have it installed."
+        )
+      end
+
+      def app_available? name
+        return system("which #{name} &> /dev/null")
+      end
+
+      def docker_machine_exists? name
+        return system("docker-machine inspect #{name} &> /dev/null")
+      end
+
+      def validate_directory directory
+        return  if (is_directory? directory)
+        error(
+          "Directory `#{directory.to_s}' does not exist or is a file."
+        )
+      end
+
+      def validate_directory_doesnt_exist directory
+        error(
+          "Directory `#{directory.to_s}' already exists."
+        )  if (is_directory?(directory) || is_file?(directory))
+      end
+
+      def is_directory? directory
+        return File.directory? directory
+      end
+
+      def is_file? file
+        return File.file? file
+      end
+
+      def prompt_to_replace_file file
+        options = {
+          overwrite: ?o,
+          append:    ?a,
+          nothing:   ?N
+        }
+        warning_print(
+          "File `#{file.to_s}' already exists. What do you want to do?",
+          "  Overwrite file? (Remove existing and create new archive.) [#{options[:overwrite]}]",
+          "  Append content to existing archive? [#{options[:append]}]",
+          "  Do nothing, abort. [#{options[:nothing]}]",
+          "[#{options.values.join(?/)}] "
+        )
+        answer = STDIN.gets[0].strip.downcase
+        case answer
+        when options[:overwrite].downcase
+          message "Overwriting archive `#{file.to_s}'."
+          File.delete file
+        when options[:append].downcase
+          message "Appending to archive `#{file.to_s}'."
+        when options[:nothing].downcase, ''
+          message "Exiting."
+          abort
+        else
+          prompt_to_replace_file file
+          return
+        end
+      end
+
+      def prompt_to_replace_docker_machine name
+        options = {
+          backup:    ?B,
+          overwrite: ?o,
+          nothing:   ?n
+        }
+        warning_print(
+          "Docker machine `#{name}' already exists. What do you want to do?",
+          "  Backup current configurations and create new one from import? [#{options[:backup]}]",
+          "    (Backup to #{DM_BACKUP_PATH})",
+          "  Overwrite existing files? [#{options[:overwrite]}]",
+          "  Do nothing, abort. [#{options[:nothing]}]",
+          "[#{options.values.join(?/)}] "
+        )
+        answer = STDIN.gets[0].strip.downcase
+        case answer
+        when options[:overwrite].downcase
+          message "Overwriting existing configuration files for `#{name}'."
+        when options[:backup].downcase, ''
+          backup_docker_machine name
+        when options[:nothing].downcase
+          message "Exiting."
+          abort
+        else
+          prompt_to_replace_docker_machine name
+          return
+        end
+      end
+
+      def backup_docker_machine name
+        backup_name_date = "#{name}.#{Time.now.strftime('%Y-%m-%d')}"
+        mk_backup_directories
+        machine_path        = DM_MACHINES_PATH.join name
+        cert_path           = DM_CERTS_PATH.join    name
+
+        #backup_machine_path = DM_BACKUP_MACHINES_PATH.join backup_name_date
+        #backup_cert_path    = DM_BACKUP_CERTS_PATH.join    backup_name_date
+
+        backup_machine_path = backup_cert_path = nil
+        backup_machine_path = get_backup_directory_for DM_BACKUP_MACHINES_PATH.join(backup_name_date)  if (machine_path.directory?)
+        backup_cert_path    = get_backup_directory_for DM_BACKUP_CERTS_PATH.join(backup_name_date)     if (cert_path.directory?)
+
+        msg = [ "Backing-up configuration files for `#{name}' to" ]
+        msg << "  `#{backup_machine_path}'"  if (backup_machine_path)
+        msg[-1] += ', and'                   if (backup_machine_path && backup_cert_path)
+        msg << "  `#{backup_cert_path}'"     if (backup_cert_path)
+        message msg
+        FileUtils.mv machine_path, backup_machine_path  if (backup_machine_path)
+        FileUtils.mv cert_path,    backup_cert_path     if (backup_cert_path)
+      end
+
+      def mk_backup_directories
+        DM_BACKUP_MACHINES_PATH.mkpath  unless (DM_BACKUP_MACHINES_PATH.directory?)
+        DM_BACKUP_CERTS_PATH.mkpath     unless (DM_BACKUP_CERTS_PATH.directory?)
+      end
+
+      def get_backup_directory_for base_backup_directory
+        base_backup_directory = Pathname.new base_backup_directory  unless (base_backup_directory.is_a? Pathname)
+        return base_backup_directory                                unless (base_backup_directory.directory?)
+        base_backup_directory_tmp = base_backup_directory.dup
+        counter = 0
+        while (base_backup_directory_tmp.directory?)
+          counter += 1
+          base_backup_directory_tmp = Pathname.new "#{base_backup_directory.to_path}_#{counter}"
+        end
+        return base_backup_directory_tmp
+      end
+  end
+end

data/lib/machine_configure.rb

@@ -0,0 +1,56 @@
+require 'bundler/setup'
+require 'argument_parser'
+require 'fileutils'
+require 'pathname'
+require 'zip'
+
+module MachineConfigure
+  entry_file = Pathname.new(__FILE__).realpath
+  root       = entry_file.dirname
+
+  HOME = Dir.home.chomp ?/
+  DIR = {
+    caller:  Pathname.new($0).realpath,
+    entry:   entry_file,
+    root:    root,
+    src:     root.join('machine_configure'),
+    helpers: root.join('machine_configure/helpers')
+  }
+
+  # This constant will replace any occurences of
+  # the user's home directory path in the
+  # docker-machine's config.json file.
+  HOME_REPLACE_STRING = '<REPLACE_WITH_HOME>'
+
+  # This string will be used as the filename for an
+  # additional file, which will only have the machine name in it.
+  MACHINE_NAME_FILENAME = 'MACHINE_NAME'
+
+  # The path to the docker-machine storage directory.
+  # <tt>$MACHINE_STORAGE_PATH</tt> or <tt>'~/.docker/machine'</tt>.
+  DM_STORAGE_PATH = (ENV['MACHINE_STORAGE_PATH'] ? (
+    Pathname.new(ENV['MACHINE_STORAGE_PATH'].chomp(?/)).realpath
+  ) : (
+    Pathname.new(File.join(HOME, '.docker/machine'))
+  ))
+  # The path to the docker-machine <tt>'machines'</tt> directory.
+  DM_MACHINES_PATH = DM_STORAGE_PATH.join 'machines'
+  # The path to the docker-machine <tt>'certs'</tt> directory.
+  DM_CERTS_PATH = DM_STORAGE_PATH.join 'certs'
+  # The paths for the machines backup directories <em>(Created by this script.)</em>.
+  DM_BACKUP_PATH          = DM_STORAGE_PATH.join("#{DIR[:caller].basename}.backup")
+  DM_BACKUP_MACHINES_PATH = DM_BACKUP_PATH.join('machines')
+  DM_BACKUP_CERTS_PATH    = DM_BACKUP_PATH.join('certs')
+
+  require DIR[:src].join     'meta'
+  require DIR[:helpers].join 'shared'
+  require DIR[:helpers].join 'message'
+  require DIR[:src].join     'validator'
+  require DIR[:src].join     'exporter'
+  require DIR[:src].join     'importer'
+  require DIR[:src].join     'cli_constants'
+  require DIR[:src].join     'cli'
+
+  VALIDATOR = Validator.new
+  VALIDATOR.validate_base_apps
+end

data/machine_configure.gemspec

@@ -0,0 +1,36 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib)  unless $LOAD_PATH.include?(lib)
+require 'machine_configure/meta'
+github_url = 'https://github.com/Noah2610/MachineConfigure'
+
+Gem::Specification.new do |spec|
+  spec.name        = MachineConfigure::GEM_NAME
+  spec.version     = MachineConfigure::VERSION
+  spec.authors     = ['Noah Rosenzweig']
+  spec.email       = ['rosenzweig.noah@gmail.com']
+  spec.summary     = 'Manage your docker-machines\' configuration files.'
+  spec.description = <<-END
+    This gem can import or export the necessary configuration files
+    for your docker-machine configuration.
+    Use it to share your machine instances with others.
+  END
+  spec.homepage    = github_url
+  spec.license     = 'MIT'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path('..', __FILE__)) do
+    `git ls-files -z`.split(?\x0).reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler',  '~> 1.16'
+  #spec.add_development_dependency 'byebug'
+  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'rake',     '~> 10.0'
+  spec.add_development_dependency 'rdoc'
+
+  spec.add_dependency 'rubyzip', '~> 1.2'
+end

data/vimrc

@@ -0,0 +1 @@
+nmap <leader>rd :!bin/rdoc<CR>

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: machine_configure
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Noah Rosenzweig
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2018-07-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.16'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubyzip
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: |2
+      This gem can import or export the necessary configuration files
+      for your docker-machine configuration.
+      Use it to share your machine instances with others.
+email:
+- rosenzweig.noah@gmail.com
+executables:
+- maccon
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- Gemfile.lock
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/rdoc
+- bin/setup
+- exe/maccon
+- lib/machine_configure.rb
+- lib/machine_configure/cli.rb
+- lib/machine_configure/cli_constants.rb
+- lib/machine_configure/exporter.rb
+- lib/machine_configure/helpers/message.rb
+- lib/machine_configure/helpers/shared.rb
+- lib/machine_configure/importer.rb
+- lib/machine_configure/meta.rb
+- lib/machine_configure/validator.rb
+- machine_configure.gemspec
+- vimrc
+homepage: https://github.com/Noah2610/MachineConfigure
+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: []
+rubyforge_project: 
+rubygems_version: 2.7.7
+signing_key: 
+specification_version: 4
+summary: Manage your docker-machines' configuration files.
+test_files: []