superhosting 0.0.1 → 0.0.2

data/lib/superhosting/docker_api.rb

@@ -1,5 +1,10 @@
 module Superhosting
   class DockerApi
+    include Helper::Cmd
+    include Helper::Logger
+
+    AVAILABLE_DOCKER_OPTIONS = [:user, :cpu_period, :cpu_quota, :cpu_shares, :memory, :memory_swap]
+
     def initialize(**kwargs)
       @socket = kwargs[:socket] || '/var/run/docker.sock'
     end
@@ -12,20 +17,179 @@ module Superhosting
       JSON.load(resp.body) if resp.status == 200
     end
 
+    def image_info(name)
+      resp_if_success raw_connection.request(method: :get, path: "/images/#{name}/json")
+    end
+
     def container_info(name)
       resp_if_success raw_connection.request(method: :get, path: "/containers/#{name}/json")
     end
 
-    def container_kill(name)
-      resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/kill")
+    def container_list
+      resp_if_success raw_connection.request(method: :get, path: '/containers/json')
+    end
+
+    def container_kill!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage.delete(name) if dry_run
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/kill") unless dry_run
+        end
+        blk.call(code: :killed)
+      end
     end
 
-    def container_rm(name)
-      resp_if_success raw_connection.request(method: :delete, path: "/containers/#{name}")
+    def container_rm!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage.delete(name) if dry_run
+          resp_if_success raw_connection.request(method: :delete, path: "/containers/#{name}") unless dry_run
+        end
+        blk.call(code: :removed)
+      end
     end
 
-    def container_list
-      resp_if_success raw_connection.request(method: :get, path: '/containers/json')
+    def container_stop!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage[name] = 'exited' if dry_run
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/stop") unless dry_run
+        end
+        blk.call(code: :stopped)
+      end
+    end
+
+    def container_start!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage[name] = 'running' if dry_run
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/start") unless dry_run
+        end
+        blk.call(code: :started)
+      end
+    end
+
+    def container_pause!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage[name] = 'paused' if dry_run
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/pause") unless dry_run
+        end
+        blk.call(code: :paused)
+      end
+    end
+
+    def container_unpause!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage[name] = 'running' if dry_run
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/unpause") unless dry_run
+        end
+        blk.call(code: :unpaused)
+      end
+    end
+
+    def container_restart!(name)
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          resp_if_success raw_connection.request(method: :post, path: "/containers/#{name}/restart") unless dry_run
+          self.storage[name] = 'running' if dry_run
+        end
+        blk.call(code: :restarted)
+      end
+    end
+
+    def container_rm_inactive!(name)
+      self.container_rm!(name) if self.container_exists?(name) and !self.container_running?(name)
+    end
+
+    def container_status?(name, status)
+      self.with_dry_run do |dry_run|
+        return true if dry_run and self.storage[name] == status
+        resp = container_info(name)
+        if resp.nil?
+          false
+        else
+          resp['State'][status.capitalize]
+        end
+      end
+    end
+
+    def container_running?(name)
+      self.with_dry_run do |dry_run|
+        return true if dry_run and self.storage[name] == 'running'
+        resp = container_info(name)
+        if resp.nil?
+          false
+        else
+          resp['State']['Running'] and %w(Restarting Paused OOMKilled Dead).all? {|c| !resp['State'][c] }
+        end
+      end
+    end
+
+    def container_not_running?(name)
+      !container_running?(name)
+    end
+
+    def container_restarting?(name)
+      container_status?(name, 'restarting')
+    end
+
+    def container_paused?(name)
+      container_status?(name, 'paused')
+    end
+
+    def container_exited?(name)
+      container_status?(name, 'exited')
+    end
+
+    def container_dead?(name)
+      container_status?(name, 'dead')
+    end
+
+    def container_not_exists?(name)
+      !container_exists?(name)
+    end
+
+    def container_exists?(name)
+      self.with_dry_run do |dry_run|
+        return true if dry_run and self.storage.key? name
+        container_info(name).nil? ? false : true
+      end
+    end
+
+    def container_image?(name, image)
+      container = container_info(name)
+      image = image_info(image)
+
+      if container.nil? or image.nil?
+        false
+      else
+        container['Image'] == image['Id']
+      end
+    end
+
+    def container_run(name, options, image, command)
+      cmd = "docker run --detach --name #{name} #{options.join(' ')} #{image} #{command}"
+      self.debug_operation(desc: { code: :container, data: { name: name } }) do |&blk|
+        self.with_dry_run do |dry_run|
+          self.storage[name] = 'running' if dry_run
+        end
+
+        self.command!(cmd).tap do
+          blk.call(code: :added)
+        end
+      end
+    end
+
+    def grab_container_options(command_options)
+      options = []
+      AVAILABLE_DOCKER_OPTIONS.map do |k|
+        unless (value = command_options[k]).nil?
+          value.lines.each {|val| options << "--#{k.to_s.sub('_', '-')} #{val}" }
+        end
+      end
+      options
     end
   end
 end

data/lib/superhosting/helper/cmd.rb

@@ -0,0 +1,40 @@
+module Superhosting
+  module Helper
+    module Cmd
+      def command!(*command_args, **kwargs)
+        self._command(*command_args, **kwargs) do |cmd|
+          raise NetStatus::Exception.new(error: :error, code: :command_with_error, data: { error: [cmd.stdout, cmd.stderr].join("\n") })
+        end
+      end
+
+      def command(*command_args, **kwargs)
+        self._command(command_args, **kwargs)
+      end
+
+      def _command(*command_args, debug: true, logger: nil, &b)
+        self.with_logger(logger: logger) do
+          desc = { code: :command, data: { command: command_args.join } }
+          if debug
+            self.debug_operation(desc: desc) do |&blk|
+              self._command_without_debug(*command_args, &b)
+              blk.call(code: :ok)
+            end
+          else
+            self._command_without_debug(*command_args, &b)
+          end
+          {} # net_status
+        end
+      end
+
+      def _command_without_debug(*command_args)
+        self.with_dry_run do |dry_run|
+          unless dry_run
+            cmd = Mixlib::ShellOut.new(*command_args)
+            cmd.run_command
+            yield cmd if block_given? and !cmd.status.success?
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superhosting/helper/config.rb

@@ -0,0 +1,80 @@
+module Superhosting
+  module Helper
+    module Config
+      def configure(name:)
+        self._config(name: name, on_reconfig: false, on_config: true)
+        {}
+      end
+
+      def unconfigure(name:)
+        case self.index[name][:mapper].parent.name
+          when 'containers'
+            registry_mapper = self.index[name][:mapper].lib.registry.container
+          when 'sites'
+            registry_mapper = self.index[name][:container_mapper].lib.registry.sites.f(name)
+          else raise NetStatus::Exception, { error: :logical_error, code: :mapper_type_not_supported, data: { name: type } }
+        end
+
+        unless registry_mapper.nil?
+          registry_mapper.lines.each {|path| PathMapper.new(path).delete! }
+          registry_mapper.delete!
+        end
+        {}
+      end
+
+      def apply(name:)
+        self._config(name: name, on_reconfig: true, on_config: false)
+        {}
+      end
+
+      def unapply(name:)
+        apply(name: name)
+      end
+
+      def configure_with_apply(name:)
+        self._config(name: name, on_reconfig: true, on_config: true)
+        {}
+      end
+
+      def unconfigure_with_unapply(name:)
+        self.unconfigure(name: name)
+        self.unapply(name: name)
+      end
+
+      def reconfig(name:)
+        self.unconfigure(name: name)
+        self.configure(name: name)
+      end
+
+      def _config(name:, on_reconfig:, on_config:)
+        mapper = self.index[name][:mapper]
+        options = self._config_options(name: name, on_reconfig: on_reconfig, on_config: on_config)
+        registry_mapper = options.delete(:registry_mapper)
+        registry_files = []
+
+        mapper.f('config.rb', overlay: false).reverse.each do |config|
+          ex = ConfigExecutor.new(options)
+          ex.execute(config)
+          ex.run_commands
+          registry_files += ex.registry_files
+        end
+
+        self._save_registry!(registry_mapper, registry_files) if on_config
+      end
+
+      def _config_options(name:, on_reconfig:, on_config:)
+        {}
+      end
+
+      def _save_registry!(registry_mapper, registry_files)
+        old_configs = registry_mapper.lines
+        unless (old_configs = old_configs - registry_files).empty?
+          self.debug_block(desc: { code: :deleting_old_configs }) do
+            old_configs.each { |file| PathMapper.new(file).delete! }
+          end
+        end
+        registry_mapper.override!(registry_files.join("\n"))
+      end
+    end
+  end
+end

data/lib/superhosting/helper/file.rb

@@ -0,0 +1,56 @@
+module Superhosting
+  module Helper
+    module File
+      def safe_link!(path_to, path)
+        self.debug_operation(desc: { code: :symlink, data: { path_to: path_to, path: path } }) do |&blk|
+          if ::File.exist? path
+            blk.call(code: :ok)
+          else
+            self.with_dry_run do |dry_run|
+              ::File.symlink(path_to, path) unless dry_run
+              blk.call(code: :created)
+            end
+          end
+        end
+      end
+
+      def safe_unlink!(path)
+        if ::File.exist? path
+          self.debug_operation(desc: { code: :symlink, data: { path: path } }) do |&blk|
+            self.with_dry_run do |dry_run|
+              ::File.unlink(path) unless dry_run
+              blk.call(code: :deleted)
+            end
+          end
+        end
+      end
+
+      def chown_r!(user, group, path)
+        self.debug_operation(desc: { code: :chown_r, data: { user: user, group: group, path: path } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            FileUtils.chown_R(user, group, path) unless dry_run
+            blk.call(code: :ok)
+          end
+        end
+      end
+
+      def chown!(user, group, path)
+        self.debug_operation(desc: { code: :chown, data: { user: user, group: group, path: path } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            FileUtils.chown(user, group, path) unless dry_run
+            blk.call(code: :ok)
+          end
+        end
+      end
+
+      def chmod!(mode, path)
+        self.debug_operation(desc: { code: :chmod, data: { mode: mode, path: path } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            FileUtils.chmod(mode, path) unless dry_run
+            blk.call(code: :ok)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superhosting/helper/i18n.rb

@@ -0,0 +1,13 @@
+module Superhosting
+  module Helper
+    module I18n
+      def i18n_initialize
+        ::I18n.load_path << "#{::File.dirname(::File.dirname(__FILE__))}/config/net_status.yml"
+        ::I18n.reload!
+        ::I18n.locale = :en
+      end
+    end
+  end
+end
+
+Superhosting::Helper::I18n.send(:extend, Superhosting::Helper::I18n)

data/lib/superhosting/helper/logger.rb

@@ -0,0 +1,136 @@
+module Superhosting
+  module Helper
+    module Logger
+      def __logger
+        Thread.current[:logger]
+      end
+
+      def __logger=(val)
+        Thread.current[:logger] = val
+      end
+
+      def with_logger(logger: nil)
+        old = self.__logger
+        self.__logger = nil if logger.is_a? FalseClass
+        yield
+      ensure
+        self.__logger = old
+      end
+
+      def __dry_run
+        Thread.current[:dry_run]
+      end
+
+      def __dry_run=(val)
+        Thread.current[:dry_run] = val
+      end
+
+      def with_dry_run
+        old = __dry_run
+        yield old
+      ensure
+        __dry_run = old
+      end
+
+      def storage
+        Thread.current[:dry_storage] ||= {}
+      end
+
+      def __debug
+        Thread.current[:debug]
+      end
+
+      def info(msg=nil, indent: true, desc: nil, **kwargs, &b)
+        unless self.__logger.nil?
+          msg = indent ? with_indent(msg) : msg.chomp
+          msg = kwargs if msg.empty? # TODO
+          self.__logger.info(msg, &b)
+        end
+        {} # net_status
+      end
+
+      def debug(msg=nil, indent: true, desc: nil, &b)
+        unless self.__logger.nil?
+          unless desc.nil?
+            (desc[:data] ||= {})[:msg] = msg
+            msg = t(desc: desc)
+          end
+          msg = indent ? with_indent(msg) : msg.chomp
+          self.__logger.debug(msg, &b)
+        end
+        {} # net_status
+      end
+
+      def debug_operation(desc: nil, &b)
+        old = self.indent
+
+        status = :failed
+        diff = nil
+        resp = b.call do |resp|
+          status = resp[:code] || :ok
+          diff = resp[:diff]
+        end
+
+        resp
+      rescue Exception => e
+        raise
+      ensure
+        desc[:code] = :"#{desc[:code]}.#{status}"
+        self.debug(desc: desc)
+        self.debug(diff, indent: false) if !diff.nil? and self.__debug
+        self.indent = old
+      end
+
+      def debug_block(desc: nil, operation: false, &b)
+        old = self.indent
+
+        self.debug(desc: desc)
+        self.indent_step
+
+        status = :failed
+        resp = yield
+        status = :ok
+
+        resp
+      rescue Exception => e
+        raise
+      ensure
+        self.debug(desc: { code: status })
+        self.indent = old
+      end
+
+      def t(desc: {}, context: nil)
+        code = desc[:code]
+        data = desc[:data]
+        ::I18n.t [:debug, context, code].join('.'), [:debug, code].join('.'), **data, raise: true
+      rescue ::I18n::MissingTranslationData => e
+        raise NetStatus::Exception, { code: :missing_translation, data: { code: code } }
+      end
+
+      def indent
+        @@indent ||= self.indent_reset
+      end
+
+      def indent=(val)
+        @@indent = val
+      end
+
+      def indent_reset
+        self.indent = 0
+      end
+
+      def indent_step
+        self.indent += 1
+      end
+
+      def indent_step_back
+        self.indent -= 1
+      end
+
+      def with_indent(msg)
+        ind = "#{' ' * 4 * self.indent }"
+        "#{ind}#{msg.to_s.sub("\n", "\n#{ind}")}"
+      end
+    end
+  end
+end