superhosting 0.0.1 → 0.0.2

data/lib/superhosting/controller/container/admin.rb

@@ -2,21 +2,43 @@ module Superhosting
   module Controller
     class Container
       class Admin < Base
-        def initialize(name:, **kvargs)
+        def initialize(name:, **kwargs)
+          super(kwargs)
           @container_name = name
-          super(kvargs)
+          @user_controller = self.get_controller(User)
+          @admin_controller = self.get_controller(Controller::Admin)
         end
 
         def list
+          container_admins = self._list
+          { data: container_admins }
+        end
 
+        def _list
+          self._list_users.map do |user|
+            { admin: user[/(?<=#{@container_name}_admin_)(.*)/], user: user }
+          end
         end
 
         def add(name:)
-
+          if (resp = @admin_controller.existing_validation(name: name)).net_status_ok?
+            admin_container_controller = self.get_controller(Controller::Admin::Container, name: name)
+            resp = admin_container_controller.add(name: @container_name)
+          end
+          resp
         end
 
         def delete(name:)
+          if (resp = @admin_controller.existing_validation(name: name)).net_status_ok?
+            admin_container_controller = self.get_controller(Controller::Admin::Container, name: name)
+            resp = admin_container_controller.delete(name: @container_name)
+          end
+          resp
+        end
 
+        def _list_users
+          users = @user_controller._group_get_users_names(name: @container_name)
+          users.select {|user| user.start_with? "#{@container_name}_admin_" }
         end
       end
     end

data/lib/superhosting/controller/container/states.rb

@@ -0,0 +1,296 @@
+module Superhosting
+  module Controller
+    class Container
+      include Helper::States
+
+      def install_data(name:, mail: 'model', admin_mail: nil, model: nil)
+        if !(resp = self.adding_validation(name: name)).net_status_ok?
+          return resp
+        elsif (model_ = model || @config.containers.f(name).f('model', default: @config.default_model)).nil?
+          return { error: :input_error, code: :no_model_given }
+        end
+
+        # model
+        model_mapper = @config.models.f(model_)
+        return { error: :input_error, code: :model_does_not_exists, data: { name: model_ } } unless @config.models.f(model_).dir?
+        etc_mapper = @config.containers.f(name).create!
+        etc_mapper.model.put!(model) unless model.nil?
+
+        # config
+        self.reindex_container(name: name)
+        mapper = self.index[name][:mapper]
+
+        # mail
+        unless mail != 'no'
+          if mail == 'yes'
+            mapper.mail.put!(mail)
+            unless (admin_mail_ = admin_mail).nil?
+              mapper.admin_mail.put!(admin_mail_)
+            end
+          elsif mail == 'model'
+            if model_mapper.default_mail == 'yes'
+              admin_mail_ = admin_mail || model_mapper.default_admin_mail
+            end
+          end
+          return { error: :input_error, code: :option_admin_mail_required } if defined? admin_mail_ and admin_mail_.nil?
+        end
+
+        # lib
+        mapper.lib.config.delete!
+        mapper.lib.config.create!
+        mapper.lib.web.create!
+
+        # web
+        PathMapper.new('/web').create!
+        safe_link!(mapper.lib.web.path, mapper.web.path)
+        {}
+      end
+
+      def uninstall_data(name:)
+        if self.index.include? name
+          mapper = self.index[name][:mapper]
+
+          # lib
+          safe_unlink!(mapper.web.path)
+          mapper.lib = mapper.lib
+          mapper.lib.web.delete!
+          mapper.lib.config.delete!
+          mapper.lib.delete!
+
+          # config
+          mapper.delete!
+
+          self.reindex_container(name: name)
+        end
+
+        {}
+      end
+
+      def install_users(name:)
+        mapper = self.index[name][:mapper]
+
+        # user / group
+        user_controller = self.get_controller(User)
+        user_controller._group_pretty_add(name: name)
+        unless (resp = user_controller._pretty_add_custom(name: name, group: name)).net_status_ok?
+          return resp
+        end
+        user = user_controller._get(name: name)
+
+        self.with_dry_run do |dry_run|
+          user_gid = if dry_run
+            'XXXX' if user.nil?
+          else
+            user.gid
+          end
+
+          mapper.lib.config.f('etc-group').append_line!("#{name}:x:#{user_gid}:") unless user_gid.nil?
+        end
+
+        # system users
+        current_system_users = user_controller._group_get_system_users(name: name)
+        add_users = mapper.system_users.lines - current_system_users
+        del_users = current_system_users - mapper.system_users.lines
+        add_users.each do |u|
+          unless (resp = user_controller._add_system_user(name: u.strip, container_name: name)).net_status_ok?
+            return resp
+          end
+        end
+        del_users.each do |u|
+          user_name = "#{name}_#{u.strip}"
+          user = user_controller._get(name: user_name)
+          unless (resp = user_controller._del(name: user_name)).net_status_ok?
+            return resp
+          end
+          mapper.lib.config.f('etc-passwd').remove_line!(/^#{user_name}:.*/)
+        end
+
+        # docker
+        PathMapper.new('/etc/security/docker.conf').append_line!("@#{name} #{name}")
+
+        # chown
+        chown_r!(name, name, mapper.lib.web.path)
+        {}
+      end
+
+      def uninstall_users(name:)
+        mapper = self.index[name][:mapper]
+
+        user_controller = self.get_controller(User)
+        if (user = user_controller._get(name: name))
+          mapper.lib.config.f('etc-group').remove_line!("#{name}:x:#{user.gid}:")
+        end
+
+        user_controller._group_del_users(name: name)
+        user_controller._group_pretty_del(name: name)
+
+        # docker
+        PathMapper.new('/etc/security/docker.conf').remove_line!("@#{name} #{name}")
+
+        {}
+      end
+
+      def configure(name:)
+        self._each_site(name: name) do |controller, sname, state|
+          controller.configure(name: sname).net_status_ok!
+        end
+        super
+      end
+
+      def unconfigure(name:)
+        self._each_site(name: name) do |controller, sname, state|
+          controller.unconfigure(name: sname).net_status_ok! # TODO: unchanged site status
+        end
+        super
+      end
+
+      def apply(name:)
+        self._each_site(name: name) do |controller, sname, state|
+          controller.apply(name: sname).net_status_ok!
+        end
+        super
+      end
+
+      def configure_with_apply(name:)
+        self._each_site(name: name) do |controller, sname, state|
+          controller.reconfigure(name: sname).net_status_ok!
+        end
+        super
+      end
+
+      def run(name:)
+        mapper = self.index[name][:mapper]
+
+        if (resp = self._collect_docker_options(mapper: mapper)).net_status_ok?
+          command_options, image, command = resp[:data]
+          dump_command_option = (command_options + [command]).join("\n")
+          dummy_signature_md5 = Digest::MD5.new.digest(dump_command_option)
+
+          restart = (!image.compare_with(mapper.lib.image) or (dummy_signature_md5 != mapper.lib.signature.md5))
+
+          if (resp = self._safe_run_docker(command_options, image, command, name: name, restart: restart)).net_status_ok?
+            mapper.lib.image.put!(image, logger: false)
+            mapper.lib.signature.put!(dump_command_option, logger: false)
+          end
+        end
+        resp
+      end
+
+      def run_mux(name:)
+        resp = {}
+        mapper = self.index[name][:mapper]
+
+        if (mux_mapper = mapper.mux).file?
+          mux_name = "mux-#{mux_mapper.value}"
+          mux_controller = self.get_controller(Mux)
+          resp = mux_controller.add(name: mux_name) if mux_controller.not_running_validation(name: mux_name).net_status_ok?
+          mux_controller.index_push(mux_name, name)
+        end
+
+        resp
+      end
+
+      def stop_mux(name:)
+        mapper = self.index[name][:mapper]
+
+        if (mux_mapper = mapper.mux).file?
+          mux_name = "mux-#{mux_mapper.value}"
+          mux_controller = self.get_controller(Mux)
+          mux_controller.index_pop(mux_name, name)
+          self._delete_docker(name: mux_name) unless mux_controller.index.include?(mux_name)
+        end
+
+        {}
+      end
+
+      def stop(name:)
+        self._delete_docker(name: name)
+        self.get_controller(Mux).reindex
+        {}
+      end
+
+      def _config_options(name:, on_reconfig:, on_config:)
+        mapper = self.index[name][:mapper]
+        model = mapper.model(default: @config.default_model)
+        model_mapper = @config.models.f(:"#{model}")
+        registry_mapper = mapper.lib.registry.f('container')
+        mux_mapper = self.index[name][:mux_mapper]
+
+        {
+            container: mapper,
+            mux: mux_mapper,
+            model: model_mapper,
+            registry_mapper: registry_mapper,
+            on_reconfig: on_reconfig,
+            on_config: on_config,
+            etc: @config,
+            lib: @lib,
+            docker_api: @docker_api
+        }
+      end
+
+      def _delete_docker(name:)
+        if @docker_api.container_exists?(name)
+          @docker_api.container_unpause!(name) if @docker_api.container_paused?(name)
+          @docker_api.container_kill!(name)
+          @docker_api.container_rm!(name)
+        end
+      end
+
+      def _recreate_docker(*docker_options, name:)
+        docker_options ||= self._collect_docker_options(mapper: self.index[name][:mapper]).net_status_ok!
+        self._delete_docker(name: name)
+        self._run_docker(*docker_options, name: name)
+      end
+
+      def _run_docker(*docker_options, name:)
+        docker_options = self._collect_docker_options(mapper: self.index[name][:mapper]).net_status_ok![:data] if docker_options.empty?
+        @docker_api.container_run(name, *docker_options)
+      end
+
+      def _safe_run_docker(*docker_options, name:, restart: false)
+        if restart
+          self._recreate_docker(*docker_options, name: name)
+        elsif @docker_api.container_exists?(name)
+          if @docker_api.container_dead?(name)
+            self._recreate_docker(*docker_options, name: name)
+          elsif @docker_api.container_exited?(name)
+            @docker_api.container_start!(name)
+          elsif @docker_api.container_paused?(name)
+            @docker_api.container_unpause!(name)
+          elsif @docker_api.container_restarting?(name)
+            Polling.start 10 do
+               break unless @docker_api.container_restarting?(name)
+               sleep 2
+            end
+          end
+        else
+          self._run_docker(*docker_options, name: name)
+        end
+        self.running_validation(name: name)
+      end
+
+      def _collect_docker_options(mapper:, model_or_mux: nil)
+        model_or_mux ||= mapper.f('model', default: @config.default_model)
+        return { error: :input_error, code: :no_docker_image_specified_in_model_or_mux, data: { name: model_or_mux } } if (image = mapper.docker.image).nil?
+
+        all_options = mapper.docker.grep_files.map {|n| [n.name[/(.*(?=\.erb))|(.*)/].to_sym, n.value] }.to_h
+        return { error: :logical_error, code: :docker_command_not_found } if (command = all_options[:command]).nil?
+
+        command_options = @docker_api.grab_container_options(all_options)
+        volume_opts = []
+        mapper.docker.f('volume', overlay: false).each {|v| volume_opts += v.lines unless v.nil? }
+        volume_opts.each {|val| command_options << "--volume #{val}" }
+
+        { data: [command_options, image, command] }
+      end
+
+      def _each_site(name:)
+        site_controller = self.get_controller(Superhosting::Controller::Site)
+        site_controller._list(container_name: name).each do |site_name, data|
+          yield site_controller, site_name, data[:state]
+        end
+      end
+    end
+  end
+end

data/lib/superhosting/controller/model.rb

@@ -0,0 +1,62 @@
+module Superhosting
+  module Controller
+    class Model < Base
+      def initialize(**kwargs)
+        super
+        @container_controller = self.get_controller(Container)
+      end
+
+      def list
+        { data: self._list }
+      end
+
+      def _list
+        models = []
+        @config.models.grep_dirs.each do |model_mapper|
+          models << model_mapper.name unless model_mapper.abstract?
+        end
+        models
+      end
+
+      def tree(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          { data: MapperInheritance::Model.new(@config.models.f(name)).collect_inheritors_tree }
+        else
+          resp
+        end
+      end
+
+      def reconfigure(name:)
+        if (resp = self.useable_validation(name: name)).net_status_ok?
+          self.index[name].each do |container_name|
+            break unless (resp = @container_controller.reconfigure(name: container_name)).net_status_ok?
+          end
+        end
+        resp
+      end
+
+      def update(name:)
+
+      end
+
+      def useable_validation(name:)
+        self.index.include?(name) ? {} : { error: :logical_error, code: :model_does_not_used, data: { name: name } }
+      end
+
+      def existing_validation(name:)
+        self._list.include?(name) ? {} : { error: :logical_error, code: :model_does_not_exists, data: { name: name } }
+      end
+
+      def index
+        index = {}
+        @container_controller._list.each do |container_name, data|
+          container_mapper = @container_controller.index[container_name][:mapper]
+          model = container_mapper.f('model', default: @config.default_model).value
+
+          (index[model] ||= []) << container_name
+        end
+        index
+      end
+    end
+  end
+end

data/lib/superhosting/controller/mux.rb

@@ -0,0 +1,88 @@
+module Superhosting
+  module Controller
+    class Mux < Base
+      attr_writer :index
+
+      def initialize(**kwargs)
+        super
+        @container_controller = self.get_controller(Container)
+      end
+
+      def add(name:)
+        if (resp = self.adding_validation(name: name))
+          mux_name = name[/(?<=mux-).*/]
+          mapper = MapperInheritance::Mux.new(@config.muxs.f(mux_name)).set_inheritors
+
+          # docker
+          mapper.erb_options = { mux: mapper }
+          if (resp = @container_controller._collect_docker_options(mapper: mapper, model_or_mux: mux_name)).net_status_ok?
+            docker_options = resp[:data]
+            @container_controller._safe_run_docker(*docker_options, name: name ).net_status_ok!
+          end
+        else
+          resp
+        end
+      end
+
+      def reconfigure(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          self.index[name].each do |container_name|
+            break unless (resp = @container_controller.reconfigure(name: container_name)).net_status_ok?
+          end
+        end
+        resp
+      end
+
+      def adding_validation(name:)
+        if (resp = @container_controller.base_validation(name: name)).net_status_ok?
+          resp = self.not_running_validation(name: name)
+        end
+        resp
+      end
+
+      def existing_validation(name:)
+        self.index.include?(name) ? {} : { error: :logical_error, code: :mux_does_not_exists, data: { name: name } }
+      end
+
+      def not_running_validation(name:)
+        @container_controller.not_running_validation(name: name).net_status_ok? ? {} : { error: :logical_error, code: :mux_is_running, data: { name: name } }
+      end
+
+      def running_validation(name:)
+        @container_controller.running_validation(name: name).net_status_ok? ? {} : { error: :logical_error, code: :mux_is_not_running, data: { name: name } }
+      end
+
+      def index
+        @@index ||= self.reindex
+      end
+
+      def reindex
+        @@index ||= {}
+        @container_controller._list.map do |container_name, data|
+          container_mapper = @container_controller.index[container_name][:mapper]
+          if (mux_mapper = container_mapper.mux).file?
+            mux_name = "mux-#{mux_mapper.value}"
+            if @container_controller.running_validation(name: container_name).net_status_ok?
+              self.index_push(mux_name, container_name)
+            else
+              self.index_pop(mux_name, container_name)
+            end
+          end
+        end
+        @@index
+      end
+
+      def index_pop(mux_name, container_name)
+        if self.index.key? mux_name
+          self.index[mux_name].delete(container_name)
+          self.index.delete(mux_name) if self.index[mux_name].empty?
+        end
+      end
+
+      def index_push(mux_name, container_name)
+        self.index[mux_name] ||= []
+        self.index[mux_name] << container_name unless self.index[mux_name].include? container_name
+      end
+    end
+  end
+end