docker-sync 0.2.3 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2c634ad99d5e88d69c686388e3346c96b3d2c30f
-  data.tar.gz: d87d180c0ca6bbe42c7b29fd8d3d90ee203edfb0
+  metadata.gz: b1fcfca4a756b6eaaaa9a278bdea971d33e06117
+  data.tar.gz: aa304239c78e91cdabe5bbb59435d24bbcd9f485
 SHA512:
-  metadata.gz: 0dbce940c38568427f7c2a845ed380caec3f41ccb6f5a3beb4d0ef16cf1913b5dc5ee4a2586785423529c242100710b09a4311d26dd436ed964e9820d86f85c9
-  data.tar.gz: ffa6b76d564ee17c3fa1a34e56a37138de831996cab2da60765aeb635b62150accd41579377e5dbaf9789005f71845b8c0242c5034f93ba5acc27b01c2c41c2a
+  metadata.gz: 6d50f3fafeb4b8cbd59c76e5735391f5becf785dbbc09ab01d8cd596d1d14cc9b62f1ecaad22c5e60296ebc61417675b3220bdd7de6f84bad3c3b283866545c8
+  data.tar.gz: 90303f06c9d494dea39ad881ecfdf3880960c62d8b6868c1f3783941a6804f738de17ba91a82b63e6de02152cca579eeb287439d12b91ba31f63e8fd8278ae18

data/VERSION

@@ -1 +1 @@
-0.2.3
+0.3.0

data/lib/docker-sync.rb

@@ -0,0 +1,4 @@
+require 'docker-sync/config/config_locator'
+require 'docker-sync/config/global_config'
+require 'docker-sync/config/project_config'
+require 'docker-sync/preconditions/strategy'

data/lib/docker-sync/config/config_locator.rb

@@ -0,0 +1,80 @@
+require 'pathname'
+
+module DockerSync
+  # helps us loading our config files, GlobalConfig and ProjectConfig
+  module ConfigLocator
+    ERROR_MISSING_PROJECT_CONFIG =
+      'No docker-sync.yml configuration found in your path ( traversing up ) '\
+      'Did you define it for your project?'.freeze
+
+    class << self
+      attr_accessor :global_config_path
+      # @return [String] The path to the global config location
+      def current_global_config_path
+        path = global_config_path
+        path = File.expand_path('~/.docker-sync-global.yml') if path.nil?
+        path
+      end
+
+      # @return [String] the path to the project configuration found
+      def lookup_project_config_path
+        files = project_config_find
+
+        raise ERROR_MISSING_PROJECT_CONFIG if files.empty?
+
+        files.pop
+      end
+
+      private
+
+
+      # this has been ruthlessly stolen from Thor/runner.rb - please do not hunt me for that :)
+      # returns a list of file paths matching the docker-sync.yml file. The return the first one we find while traversing
+      # the folder tree up
+      # @return [Array]
+      def project_config_find(skip_lookup = false)
+        # Finds docker-sync.yml by traversing from your current directory down to the root
+        # directory of your system. If at any time we find a docker-sync.yml file, we stop.
+        #
+        #
+        # ==== Example
+        #
+        # If we start at /Users/wycats/dev/thor ...
+        #
+        # 1. /Users/wycats/dev/thor
+        # 2. /Users/wycats/dev
+        # 3. /Users/wycats <-- we find a docker-sync.yml here, so we stop
+        #
+        # Suppose we start at c:\Documents and Settings\james\dev\docker-sync ...
+        #
+        # 1. c:\Documents and Settings\james\dev\docker-sync.yml
+        # 2. c:\Documents and Settings\james\dev
+        # 3. c:\Documents and Settings\james
+        # 4. c:\Documents and Settings
+        # 5. c:\ <-- no docker-sync.yml found!
+        #
+        docker_sync_files = []
+
+        unless skip_lookup
+          Pathname.pwd.ascend do |path|
+            docker_sync_files = globs_for_project_config(path).map { |g| Dir[g] }.flatten
+            break unless docker_sync_files.empty?
+          end
+        end
+
+        docker_sync_files
+      end
+
+      # Where to look for docker-sync.yml files.
+      #
+      def globs_for_project_config(path)
+        path = escape_globs(path)
+        ["#{path}/docker-sync.yml"]
+      end
+
+      def escape_globs(path)
+        path.to_s.gsub(/[*?{}\[\]]/, '\\\\\\&')
+      end
+    end
+  end
+end

data/lib/docker-sync/config/config_serializer.rb

@@ -0,0 +1,56 @@
+require 'yaml'
+require 'dotenv'
+
+module DockerSync
+  module ConfigSerializer
+    class << self
+      # @param [String] config_path path to the yaml configuration to load
+      # @return [Object] returns a Yaml hashmap, expaneded by ENV vars
+      def default_deserializer_file(config_path)
+        config_string = File.read(config_path)
+        default_deserializer_string(config_string)
+      end
+
+      # @param [String] config_string the configuration string inf yaml format
+      # @return [Object] a yaml hashmap
+      def default_deserializer_string(config_string)
+        deserialize_config( expand_env_variables(config_string) )
+      end
+
+      private
+
+      # Replaces our tokens, in this case all ENV variables we defined. Find those in the string an replace
+      # them with then values from our ENV, including the dotenv file
+      # @param [String] config_string
+      # @return [String]
+      def expand_env_variables(config_string)
+        load_dotenv
+
+        env_hash = {}
+        ENV.each {|k,v| env_hash[k.to_sym] = v }
+        config_string.gsub!('${', '%{')
+        config_string % env_hash
+      end
+
+
+      # deserializes the configuration string, right now as a yaml formatted string
+      # @param [String] config_string
+      # @return [Object]
+      def deserialize_config(config_string)
+        # noinspection RubyResolve
+        YAML.load(config_string)
+      end
+
+      # Loads the dotenv file but also lets us overide the source not being .env but anything you put
+      # into the ENV variable DOCKER_SYNC_ENV_FILE
+      # @return [Object]
+      def load_dotenv
+        # TODO: ensure we do this once only
+        env_file = ENV.fetch('DOCKER_SYNC_ENV_FILE', '.env')
+
+        # noinspection RubyResolve
+        Dotenv.load(env_file)
+      end
+    end
+  end
+end

data/lib/docker-sync/config/global_config.rb

@@ -0,0 +1,55 @@
+require 'singleton'
+require 'forwardable'
+
+require 'docker-sync/config/config_locator'
+require 'docker-sync/config/config_serializer'
+
+module DockerSync
+  class GlobalConfig
+    extend Forwardable
+    include Singleton
+
+    # noinspection RubyStringKeysInHashInspection
+    DEFAULTS = {
+      'update_check' => true,
+      'update_last_check' => DateTime.new(2001, 1, 1).iso8601(9),
+      'update_enforce' => true,
+      'upgrade_status' => '',
+    }.freeze
+
+    attr_reader :config
+    private :config
+
+    def_delegators :@config, :[], :to_h
+
+    def self.load; instance end
+
+    def initialize
+      load_global_config
+    end
+
+    def load_global_config
+      @config_path = DockerSync::ConfigLocator.current_global_config_path
+      if File.exist?(@config_path)
+        @config = DockerSync::ConfigSerializer.default_deserializer_file(@config_path)
+      end
+
+      unless @config
+        @config = DEFAULTS.dup
+        @first_run = true
+      end
+    end
+
+    def first_run?
+      @first_run
+    end
+
+    # @param [Object] updates
+    # Updates and saves the configuration back to the file
+    def update!(updates)
+      @config.merge!(updates)
+
+      File.open(@config_path, 'w') {|f| f.write @config.to_yaml }
+    end
+  end
+end

data/lib/docker-sync/config/project_config.rb

@@ -0,0 +1,123 @@
+require 'singleton'
+require 'docker-sync/config/config_locator'
+require 'docker-sync/config/config_serializer'
+
+module DockerSync
+  class ProjectConfig
+    extend Forwardable
+
+    REQUIRED_CONFIG_VERSION = '2'.freeze
+
+    ERROR_MISSING_CONFIG_VERSION =
+      "Your docker-sync.yml file does not include a version: \"#{REQUIRED_CONFIG_VERSION}\""\
+      '(Add this if you migrated from docker-sync 0.1.x)'.freeze
+
+    ERROR_MISMATCH_CONFIG_VERSION =
+      'Your docker-sync.yml file does not match the required version '\
+      "(#{REQUIRED_CONFIG_VERSION}).".freeze
+
+    ERROR_MISSING_SYNCS = 'no syncs defined'.freeze
+
+    attr_reader :config, :config_path
+    private :config
+
+    def_delegators :@config, :[], :to_h
+
+    def initialize(config_path: nil, config_string: nil)
+      if config_string.nil?
+        config_path = DockerSync::ConfigLocator.lookup_project_config_path if config_path.nil?
+        load_project_config(config_path)
+      else
+        @config = DockerSync::ConfigSerializer.default_deserializer_string(config_string)
+        @config_path = nil
+      end
+
+      validate_config!
+      normalize_config!
+    end
+
+    def load_project_config(config_path = nil)
+      @config_path = config_path
+      return unless File.exist?(@config_path)
+      @config = DockerSync::ConfigSerializer.default_deserializer_file(@config_path)
+    end
+
+    def unison_required?
+      config['syncs'].any? { |name, sync_config|
+        sync_config['sync_strategy'] == 'unison' || sync_config['watch_strategy'] == 'unison'
+      }
+    end
+
+    def rsync_required?
+      config['syncs'].any? { |name, sync_config|
+        sync_config['sync_strategy'] == 'rsync'
+      }
+    end
+
+
+    private
+
+      def validate_config!
+        raise error_missing_given_config if config.nil?
+        raise ERROR_MISSING_CONFIG_VERSION unless config.key?('version')
+        raise ERROR_MISMATCH_CONFIG_VERSION unless config['version'].to_s == REQUIRED_CONFIG_VERSION
+        raise ERROR_MISSING_SYNCS unless config.key?('syncs')
+
+        validate_syncs_config!
+      end
+
+      def validate_syncs_config!
+        config['syncs'].each do |name, sync_config|
+          validate_sync_config(name, sync_config)
+        end
+      end
+
+      def validate_sync_config(name, sync_config)
+        config_mandatory = %w[src]
+        #TODO: Implement autodisovery for other strategies
+        config_mandatory.push('sync_host_port') if sync_config['sync_strategy'] == 'rsync'
+        config_mandatory.each do |key|
+          raise ("#{name} does not have #{key} configuration value set - this is mandatory") unless sync_config.key?(key)
+        end
+      end
+
+      def error_missing_given_config
+        "Config could not be loaded from #{config_path} - it does not exist"
+      end
+
+      def normalize_config!
+        config['syncs'].each do |name, sync_config|
+          config['syncs'][name] = normalize_sync_config(sync_config)
+        end
+      end
+
+      def normalize_sync_config(sync_config)
+        {
+          'sync_strategy' => sync_strategy_for(sync_config),
+          'watch_strategy' => watch_strategy_for(sync_config)
+        }.merge(sync_config)
+      end
+
+      def sync_strategy_for(sync_config)
+        case sync_config['sync_strategy']
+        when 'rsync' then 'rsync'
+        else 'unison'
+        end
+      end
+
+      def watch_strategy_for(sync_config)
+        if sync_config.key?('watch_strategy')
+          case sync_config['watch_strategy']
+          when 'fswatch' then 'fswatch'
+          when 'disable','dummy' then 'dummy'
+          else 'unison'
+          end
+        elsif sync_config['sync_strategy'] == 'rsync'
+          'fswatch'
+        else
+          'unison'
+        end
+      end
+
+  end
+end

data/lib/docker-sync/preconditions/preconditions_linux.rb

@@ -0,0 +1,24 @@
+module DockerSync
+  module Preconditions
+    class Linux
+      def check_all_preconditions(config)
+      end
+
+      def docker_available
+      end
+
+      def docker_running
+      end
+
+      def fswatch_available
+      end
+
+      def rsync_available
+      end
+
+      def unison_available
+      end
+    end
+
+  end
+end

data/lib/docker-sync/preconditions/preconditions_osx.rb

@@ -0,0 +1,148 @@
+require 'mkmf'
+module DockerSync
+  module Preconditions
+    class Osx
+      def check_all_preconditions(config)
+        return unless should_run_precondition?
+
+        docker_available
+        docker_running
+
+        if config.unison_required?
+          unison_available
+        end
+
+        if config.rsync_required?
+          rsync_available
+          fswatch_available
+        end
+      end
+
+      def docker_available
+        if (find_executable0 'docker').nil?
+          raise('Could not find docker binary in path. Please install it, e.g. using "brew install docker" or install docker-for-mac')
+        end
+      end
+
+      def docker_running
+        `docker ps`
+        if $?.exitstatus > 0
+          raise('No docker daemon seems to be running. Did you start your docker-for-mac / docker-machine?')
+        end
+      end
+
+      def rsync_available
+        if should_run_precondition?
+          if (find_executable0 'rsync').nil?
+            raise('Could not find rsync binary in path. Please install it, e.g. using "brew install rsync"')
+          end
+        end
+      end
+
+      def unison_available
+        if should_run_precondition?
+          if (find_executable0 'unison').nil?
+            cmd1 = 'brew install unison"'
+
+            Thor::Shell::Basic.new.say_status 'warning', 'Could not find unison binary in $PATH. Trying to install now', :red
+            if Thor::Shell::Basic.new.yes?('I will install unison using brew for you? (y/N)')
+              system cmd1
+            else
+              raise('Please install it yourself using: brew install unison')
+            end
+          end
+
+          unox_available
+        end
+      end
+
+      def fswatch_available
+        if should_run_precondition?
+          if (find_executable0 'fswatch').nil?
+            cmd1 = 'brew install fswatch"'
+
+            Thor::Shell::Basic.new.say_status 'warning', 'No fswatch available. Install it by "brew install fswatch Trying to install now', :red
+            if Thor::Shell::Basic.new.yes?('I will install fswatch using brew for you? (y/N)')
+              system cmd1
+            else
+              raise('Please install it yourself using: brew install fswatch')
+            end
+          end
+        end
+
+      end
+
+      private
+
+      def should_run_precondition?(silent = false)
+        unless has_brew?
+          Thor::Shell::Basic.new.say_status 'inf', 'Not running any precondition checks since you have no brew and that is unsupported. Is all up to you know.', :white unless silent
+          return false
+        end
+        return true
+      end
+
+      def has_brew?
+        return find_executable0 'brew'
+      end
+
+
+      def unox_available
+        if should_run_precondition?
+          `brew list unox`
+          if $?.exitstatus > 0
+            unless (find_executable0 'unison-fsmonitor').nil?
+              # unox installed, but not using brew, we do not allow that anymore
+              Thor::Shell::Basic.new.say_status 'error', 'You install unison-fsmonitor (unox) not using brew. Please uninstall it and run docker-sync again, so we can install it for you', :red
+              exit 1
+            end
+            cmd1 = 'brew tap eugenmayer/dockersync && brew install eugenmayer/dockersync/unox'
+
+            Thor::Shell::Basic.new.say_status 'warning', 'Could not find unison-fsmonitor (unox) binary in $PATH. Trying to install now', :red
+            if Thor::Shell::Basic.new.yes?('I will install unox through brew for you? (y/N)')
+              system cmd1
+            else
+              raise('Please install it yourself using: brew tap eugenmayer/dockersync && brew install unox')
+            end
+          end
+        end
+      end
+
+      def install_pip(package, test = nil)
+        test ? `python -c 'import #{test}'` : `python -c 'import #{package}'`
+
+        unless $?.success?
+          Thor::Shell::Basic.new.say_status 'warning', "Could not find #{package}. Will try to install it using pip", :red
+          if find_executable0('python') == '/usr/bin/python'
+            Thor::Shell::Basic.new.say_status 'ok', 'You seem to use the system python, we will need sudo below'
+            sudo = true
+            cmd2 = "sudo easy_install pip && sudo pip install #{package}"
+          else
+            Thor::Shell::Basic.new.say_status 'ok', 'You seem to have a custom python, using non-sudo commands'
+            sudo = false
+            cmd2 = "easy_install pip && pip install #{package}"
+          end
+          if sudo
+            question = "I will ask you for you root password to install #{package} by running (This will ask for sudo, since we use the system python)"
+          else
+            question = "I will now install #{package} for you by running"
+          end
+
+          Thor::Shell::Basic.new.say_status 'info', "#{question}: `#{cmd2}\n\n"
+          if Thor::Shell::Basic.new.yes?('Shall I continue? (y/N)')
+            system cmd2
+            if $?.exitstatus > 0
+              raise("Failed to install #{package}, please file an issue with the output of the error")
+            end
+            test ? `python -c 'import #{test}'` : `python -c 'import #{package}'`
+            unless $?.success?
+              raise("Somehow I could not successfully install #{package} even though I tried. Please report this issue.")
+            end
+          else
+            raise("Please install #{package} manually, see https://github.com/EugenMayer/docker-sync/wiki/1.-Installation")
+          end
+        end
+      end
+    end
+  end
+end