superhosting 0.0.1 → 0.0.2

data/lib/superhosting/controller/mysql.rb

@@ -2,11 +2,11 @@ module Superhosting
   module Controller
     class Mysql < Base
       def db
-        Db.new
+        self.get_controller(Db)
       end
 
       def user
-        User.new
+        self.get_controller(User)
       end
 
       def grant

data/lib/superhosting/controller/site.rb

@@ -1,105 +1,250 @@
 module Superhosting
   module Controller
     class Site < Base
-      attr_reader :site_index
-
-      DOMAIN_NAME_FORMAT = /^((?!-)[A-Za-z0-9-]{1,63}(?<!-)\.)+[A-Za-z]{2,6}$/
-
-      def site_index
-        def generate
-          @site_index = {}
-          @config.containers._grep_dirs.each do |c|
-            c.sites._grep_dirs.each do |s|
-              names = []
-              names << s._name
-              s.aliases.lines {|n| names << n.strip } unless s.aliases.nil?
-              raise NetStatus::Exception.new(error: :error, message: "Conflict between container_sites: '#{@site_index[s._name][:site]._path}' and '#{s._path}'") if @site_index.key? s._name
-              names.each {|n| @site_index[n] = { container: c, site: s } }
+      DOMAIN_NAME_FORMAT = /^((?!-)[А-Яа-яA-Za-z0-9-]{1,63}(?<!-)\.)+[А-Яа-яA-Za-z]{2,6}$/
+
+      def initialize(**kwargs)
+        super(**kwargs)
+        @container_controller = self.get_controller(Container)
+        self.index
+      end
+
+      def list(container_name: nil)
+        if container_name.nil? or (resp = @container_controller.available_validation(name: container_name)).net_status_ok?
+          { data: self._list(container_name: container_name) }
+        else
+          resp
+        end
+      end
+
+      def _list(container_name: nil)
+        def data(name)
+          mapper = self.index[name][:mapper]
+          docker_options = mapper.docker.grep_files.map {|f| [f.name, f.value] }.to_h
+          configs = mapper.f('config.rb', overlay: false).reverse.map {|f| f.value }
+          { docker: docker_options, configs: configs, aliases: self.index[name][:aliases]-[name] }
+        end
+
+        sites = {}
+        if container_name
+          container_mapper = @container_controller.index[container_name][:mapper]
+          container_mapper.sites.grep_dirs.each do |mapper|
+            name = mapper.name
+            if (state = container_mapper.lib.sites.f(name).state).file?
+              sites[name] = { state: state.value, container: container_name }.merge(data(name))
+            end
+          end
+        else
+          self.index.values.each do |index|
+            name = index[:mapper].name
+            if (state = index[:state_mapper]).file?
+              sites[name] = { state: state.value, container: index[:container_mapper].name }.merge(data(name))
             end
           end
-          @site_index
         end
 
-        @site_index ||= self.generate
+        sites
       end
 
-      def add(name:, container_name:)
-        return { error: :input_error, message: "Invalid site name '#{name}' only '#{DOMAIN_NAME_FORMAT}'" } if name !~ DOMAIN_NAME_FORMAT
-        return { error: :logical_error, message: 'Site already exists.' } if self.site_index.include? name
-        return { error: :logical_error, message: "Container '#{container_name}' doesn\'t exists." } if (config_path_mapper = @config.containers.f(container_name)).nil?
-
-        site_mapper = config_path_mapper.sites.f(name)
-        FileUtils.mkdir_p site_mapper._path
+      def inspect(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          actual_name = self.index[name][:mapper].name
+          container_mapper = self.index[name][:container_mapper]
+          { data: self._list(container_name: container_mapper.name)[actual_name] }
+        else
+          resp
+        end
+      end
 
-        lib_path_mapper = PathMapper.new("#{@lib_path}/containers/#{container_name}")
-        model = config_path_mapper.model(default: @config.default_model)
-        model_mapper = @config.models.f(:"#{model}")
+      def add(name:, container_name:)
+        if (resp = @container_controller.available_validation(name: container_name)).net_status_ok? and
+            (resp = self.adding_validation(name: name)).net_status_ok?
+          resp = self._reconfigure(name: name, container_name: container_name)
+        end
+        resp
+      end
 
-        lib_sites_path = lib_path_mapper.registry.sites
-        unless model_mapper.f('site.rb').nil?
-          registry_path = lib_sites_path.f(name)._path
-          FileUtils.mkdir_p lib_sites_path._path
-          ex = ScriptExecutor::Site.new(
-              site: site_mapper, site_name: name,
-              container: config_path_mapper, container_name: name, container_lib: lib_path_mapper, registry_path: registry_path,
-              model: model_mapper, config: @config, lib: @lib
-          )
-          ex.execute(model_mapper.f('site.rb'))
-          ex.commands.each {|c| self.command c }
+      def name(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          { data: self.index[name][:mapper].name }
+        else
+          resp
         end
+      end
 
-        {}
+      def container(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          { data: self.index[name][:container_mapper].name }
+        else
+          resp
+        end
       end
 
       def delete(name:)
-        if site = self.site_index[name]
-          FileUtils.rm_rf site[:site]._path
-          container_sites = site[:container].sites
-          FileUtils.rm_rf container_sites._path if container_sites.nil?
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          lib_sites_mapper = self.index[name][:container_mapper].lib.sites
+          actual_name = self.index[name][:mapper].name
+          state_mapper = lib_sites_mapper.f(actual_name)
+
+          states = {
+              up: { action: :unapply, undo: :apply, next: :configured },
+              configured: { action: :unconfigure, next: :data_installed },
+              data_installed: { action: :uninstall_data },
+          }
+
+          self.on_state(state_mapper: state_mapper, states: states, name: actual_name)
+        end
+        resp
+      end
 
-          config_path_mapper = site[:container]
-          lib_path_mapper = PathMapper.new("#{@lib_path}/containers/#{config_path_mapper._name}")
-          model = config_path_mapper.model(default: @config.default_model)
-          model_mapper = @config.models.f(:"#{model}")
+      def rename(name:, new_name:, alias_name: false)
+        if (resp = self.available_validation(name: name)).net_status_ok? and
+          ((resp = self.adding_validation(name: new_name)).net_status_ok? or
+              (is_alias = alias_existing_validation(name: name, alias_name: new_name)))
 
-          lib_sites_path = lib_path_mapper.registry.sites
+          mapper = self.index[name][:mapper]
+          container_mapper = self.index[name][:container_mapper]
+          actual_name = mapper.name
 
-          unless (registry_site = lib_sites_path.f(name)).nil?
-            FileUtils.rm registry_site.lines
-            FileUtils.rm registry_site._path
-          end
+          mapper.aliases_mapper.remove_line!(new_name) if defined? is_alias and is_alias
+          self.reindex_container_sites(container_name: container_mapper.name)
 
-          unless model_mapper.f('site.rb').nil?
-            registry_path = lib_sites_path.f(name)._path
-            FileUtils.mkdir_p lib_sites_path._path
-            ex = ScriptExecutor::Site.new(
-                site: site[:site], site_name: name,
-                container: config_path_mapper, container_name: name, container_lib: lib_path_mapper,
-                registry_path: registry_path, on_reconfig_only: true,
-                model: model_mapper, config: @config, lib: @lib
-            )
-            ex.execute(model_mapper.f('site.rb'))
-            ex.commands.each {|c| self.command c }
+          begin
+            self.unconfigure_with_unapply(name: actual_name).net_status_ok!
+            if (resp = self._reconfigure(name: new_name, container_name: container_mapper.name)).net_status_ok?
+              new_mapper = self.index[new_name][:mapper]
+              mapper.etc.rename!(new_mapper.etc.path)
+              mapper.lib.rename!(new_mapper.lib.path)
+              mapper.aliases_mapper.rename!(new_mapper.aliases_mapper.path)
+
+              self.reconfigure(name: new_name).net_status_ok!
+              self.delete(name: actual_name).net_status_ok!
+
+              new_mapper.aliases_mapper.append_line!(actual_name) if alias_name
+              self.reindex_container_sites(container_name: container_mapper.name)
+            end
+          rescue Exception => e
+            resp = e.net_status
+            raise
+          ensure
+            unless resp.net_status_ok?
+              unless new_mapper.nil?
+                mapper.aliases_mapper.append_line!(new_name) if defined? is_alias and is_alias
+                mapper.aliases_mapper.remove_line!(name) if alias_name
+
+                new_mapper.etc.rename!(mapper.path)
+                new_mapper.lib.rename!(mapper.lib.path)
+
+                self.reconfigure(name: name)
+              end
+
+              self.delete(name: new_name)
+            end
           end
+        end
+        resp
+      end
 
-          {}
+      def reconfigure(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          actual_name = self.index[name][:mapper].name
+          self.set_state(name: actual_name, state: :data_installed)
+          self._reconfigure(name: actual_name)
         end
+        resp
       end
 
-      def rename(name:, new_name:)
-        return { error: :logical_error, message: "Site '#{name}' doesn't exists." } unless site = self.site_index[name]
-        return { error: :logical_error, message: "Site '#{new_name}' already exists." } if self.site_index[new_name]
+      def _reconfigure(name:, **kwargs)
+        lib_sites_mapper = if (container_name = kwargs[:container_name])
+          @container_controller.index[container_name][:mapper].lib.sites
+        else
+          self.index[name][:container_mapper].lib.sites
+        end
+        state_mapper = lib_sites_mapper.f(name)
 
-        FileUtils.mv site[:container].sites.f(name)._path, site[:container].sites.f(new_name)._path
+        states = {
+            none: { action: :install_data, undo: :uninstall_data, next: :data_installed },
+            data_installed: { action: :configure_with_apply, undo: :unconfigure_with_unapply, next: :up },
+        }
 
-        lib_path_mapper = PathMapper.new("#{@lib_path}/containers/#{site[:container]._name}")
-        unless (lib_sites_path = lib_path_mapper.registry.sites).nil?
-          FileUtils.mv lib_sites_path.f(name), lib_sites_path.f(new_name)
+        self.on_state(state_mapper: state_mapper, states: states,
+                      name: name, container_name: container_name, **kwargs)
+      end
+
+      def alias(name:)
+        self.get_controller(Alias, name: name)
+      end
+
+      def adding_validation(name:)
+        return { error: :input_error, code: :invalid_site_name, data: { name: name, regex: DOMAIN_NAME_FORMAT } } if name !~ DOMAIN_NAME_FORMAT
+        self.not_existing_validation(name: name)
+      end
+
+      def existing_validation(name:)
+        self.index[name].nil? ? { error: :logical_error, code: :site_does_not_exists, data: { name: name } } : {}
+      end
+
+      def alias_existing_validation(name:, alias_name:)
+        self.index[name][:mapper].aliases.include?(alias_name)
+      end
+
+      def not_existing_validation(name:)
+        self.existing_validation(name: name).net_status_ok? ? { error: :logical_error, code: :site_exists, data: { name: name} } : {}
+      end
+
+      def available_validation(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          resp = (self.index[name][:state_mapper].value == 'up') ? {} : { error: :logical_error, code: :site_is_not_available, data: { name: name }  }
+        end
+        resp
+      end
+
+      def index
+        @@index ||= self.reindex
+      end
+
+      def reindex
+        @config.containers.grep_dirs.each do |container_mapper|
+          reindex_container_sites(container_name: container_mapper.name)
         end
+        @@index ||= {}
       end
 
-      def alias(name:, logger: @logger)
-        Alias.new(name: name, logger: logger)
+      def reindex_container_sites(container_name:)
+        @config.containers.f(container_name).sites.grep_dirs.each do |site_mapper|
+          self.reindex_site(name: site_mapper.name, container_name: container_name)
+        end
+      end
+
+      def reindex_site(name:, container_name:)
+        @@index ||= {}
+        @@index[name][:aliases].each{|n| @@index.delete(n) } if @@index[name]
+
+        container_mapper = @container_controller.index[container_name][:mapper]
+        etc_mapper = container_mapper.sites.f(name)
+        lib_mapper = container_mapper.lib.web.f(name)
+        web_mapper = container_mapper.web.f(name)
+        state_mapper = container_mapper.lib.sites.f(name).state
+
+        if etc_mapper.nil?
+          @@index.delete(name)
+          return
+        end
+
+        model_name = container_mapper.f('model', default: @config.default_model)
+        model_mapper = @config.models.f(model_name)
+        etc_mapper = MapperInheritance::Model.new(model_mapper).set_inheritors(etc_mapper)
+
+        mapper = CompositeMapper.new(etc_mapper: etc_mapper, lib_mapper: lib_mapper, web_mapper: web_mapper)
+        etc_mapper.erb_options = { site: mapper, container: mapper }
+
+        if @@index.key? name and @@index[name][:mapper].path != mapper.path
+          raise NetStatus::Exception, { code: :container_site_name_conflict,
+                                        data: { site1: @@index[name][:mapper].path, site2: mapper.path } }
+        end
+
+        names = ([mapper.name] + mapper.aliases)
+        names.each {|name| @@index[name] = { mapper: mapper, container_mapper: container_mapper, state_mapper: state_mapper, aliases: names } }
       end
     end
   end

data/lib/superhosting/controller/site/alias.rb

@@ -2,18 +2,44 @@ module Superhosting
   module Controller
     class Site
       class Alias < Base
-        def initialize(name:, **kvargs)
-          raise NetStatus::Exception, { error: :logical_error, message: "Site '#{name}' doesn't exists." } unless @site_descriptor = Site.new(kvargs).site_index[name]
-          super(kvargs)
+        def initialize(name:, **kwargs)
+          super(kwargs)
+          @site_controller = self.get_controller(Site)
+          @site_controller.existing_validation(name: name).net_status_ok!
+
+          site = @site_controller.index[name]
+          @site_mapper = site[:mapper]
+          @aliases_mapper = site[:mapper].aliases_mapper
+          @container_mapper = site[:container_mapper]
         end
 
         def add(name:)
-          return { error: :input_error, message: "Invalid alias name '#{name}' - only '#{Site::DOMAIN_NAME_FORMAT}' are allowed" } if name !~ Site::DOMAIN_NAME_FORMAT
-          write_if_not_exist(@site_descriptor[:site].aliases._path, name)
+          if (resp = self.not_existing_validation(name: name)).net_status_ok? and
+            (resp = @site_controller.adding_validation(name: name)).net_status_ok?
+            @aliases_mapper.append_line!(name)
+            @site_controller.reconfigure(name: @site_mapper.name)
+
+            @site_controller.reindex_site(name: @site_mapper.name, container_name: @container_mapper.name)
+          end
+          resp
         end
 
         def delete(name:)
-          remove_line_from_file(@site_descriptor[:site].aliases._path, name)
+          if (resp = self.existing_validation(name: name)).net_status_ok?
+            @aliases_mapper.remove_line!(name)
+            @site_controller.reconfigure(name: @site_mapper.name)
+
+            @site_controller.reindex_site(name: @site_mapper.name, container_name: @container_mapper.name)
+          end
+          resp
+        end
+
+        def existing_validation(name:)
+          @aliases_mapper.lines.include?(name) ?  {} : { error: :logical_error, code: :alias_does_not_exists, data: { name: name } }
+        end
+
+        def not_existing_validation(name:)
+          self.existing_validation(name: name).net_status_ok? ? { error: :logical_error, code: :alias_exists, data: { name: name } } : {}
         end
       end
     end

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

@@ -0,0 +1,41 @@
+module Superhosting
+  module Controller
+    class Site
+      include Helper::States
+
+      def install_data(name:, container_name:)
+        container_mapper = @container_controller.index[container_name][:mapper]
+        container_mapper.sites.f(name).create!
+        site_lib_mapper = container_mapper.lib.web.f(name).create!
+
+        chown_r!(container_name, container_name, site_lib_mapper.path)
+
+        self.reindex_site(name: name, container_name: container_name)
+        {}
+      end
+
+      def uninstall_data(name:)
+        if self.index.include? name
+          container_mapper = self.index[name][:container_mapper]
+          container_mapper.sites.f(name).delete!
+          container_mapper.lib.web.f(name).delete!
+          container_mapper.lib.sites.f(name).aliases.delete!
+
+          self.reindex_site(name: name, container_name: container_mapper.name)
+        end
+        {}
+      end
+
+      def _config_options(name:, on_reconfig:, on_config:)
+        mapper = self.index[name][:mapper]
+        container_mapper = self.index[name][:container_mapper]
+        registry_mapper = container_mapper.lib.registry.sites.f(name)
+
+        @container_controller._config_options(name: container_mapper.name, on_reconfig: on_reconfig, on_config: on_config).merge! ({
+            site: mapper,
+            registry_mapper: registry_mapper
+        })
+      end
+    end
+  end
+end

data/lib/superhosting/controller/user.rb

@@ -1,24 +1,253 @@
 module Superhosting
   module Controller
     class User < Base
-      def list
+      USER_NAME_FORMAT = /^[a-zA-Z][-a-zA-Z0-9_]{,31}$/
 
+      def initialize(**kwargs)
+        super(**kwargs)
+        @container_controller = self.get_controller(Container)
       end
 
-      def add(name:, container_name:, no_ssh: false, no_ftp: false)
+      def list(container_name:)
+        if (resp = @container_controller.available_validation(name: container_name)).net_status_ok?
+          { data: self._list(container_name: container_name) }
+        else
+          resp
+        end
+      end
 
+      def _list(container_name:)
+        self._group_get_users_names(name: container_name)
       end
 
-      def passwd(generate:)
+      def add(name:, container_name:, ftp_dir: nil, ftp_only: false, generate: false)
+        return { error: :logical_error, code: :option_ftp_only_is_required } if ftp_dir and !ftp_only
+
+        web_mapper = PathMapper.new("/web/#{container_name}")
+        home_dir = ftp_dir.nil? ? web_mapper.path : web_mapper.f(ftp_dir).path
+
+        if (resp = @container_controller.available_validation(name: container_name)).net_status_ok?
+          if !File.exists? home_dir
+            resp = { error: :logical_error, code: :incorrect_ftp_dir, data: { dir: home_dir.to_s } }
+          elsif (resp = self.not_existing_validation(name: name, container_name: container_name)).net_status_ok?
+            shell = ftp_only ? '/usr/sbin/nologin' : '/bin/bash'
+            if (resp = self._add(name: name, container_name: container_name, home_dir: home_dir, shell: shell)).net_status_ok?
+              if generate
+                resp = self.passwd(name: name, container_name: container_name, generate: generate)
+              end
+            end
+          end
+        end
+        resp
+      end
 
+      def passwd(name:, container_name:, generate: false)
+        if (resp = @container_controller.available_validation(name: container_name)).net_status_ok?
+          user_name = "#{container_name}_#{name}"
+          passwords = self._create_password(generate: generate)
+          self._update_password(name: user_name, encrypted_password: passwords[:encrypted_password])
+          generate ? { data: passwords[:password] } : {}
+        else
+          resp
+        end
       end
 
       def delete(name:, container_name:)
+        if (resp = @container_controller.available_validation(name: container_name)).net_status_ok? and
+            (resp = self.existing_validation(name: name, container_name: container_name)).net_status_ok?
+          container_lib_mapper = @lib.containers.f(container_name)
+          passwd_mapper = container_lib_mapper.config.f('etc-passwd')
+          user_name = "#{container_name}_#{name}"
+          self._del(name: user_name)
+          passwd_mapper.remove_line!(/^#{user_name}:.*/)
+        end
+        resp
+      end
+
+      def change(name:, container_name:, ftp_dir: nil, ftp_only: false, generate: false)
+        if (resp = self.delete(name: name, container_name: container_name)).net_status_ok?
+          self.add(name: name, container_name: container_name, ftp_dir: ftp_dir, ftp_only: ftp_only, generate: generate)
+        else
+          resp
+        end
+      end
+
+      def _get(name:)
+        begin
+          Etc.getpwnam(name)
+        rescue ArgumentError => e
+          nil
+        end
+      end
+
+      def _add(name:, container_name:, shell: '/usr/sbin/nologin', home_dir: "/web/#{container_name}")
+        user = self._get(name: container_name)
+        self._add_custom(name: "#{container_name}_#{name}", group: container_name, shell: shell, home_dir: home_dir, uid: user.uid)
+      end
+
+      def _add_system_user(name:, container_name:, shell: '/usr/sbin/nologin', home_dir: "/web/#{container_name}")
+        self._add_custom(name: "#{container_name}_#{name}", group: container_name, shell: shell, home_dir: home_dir)
+      end
+
+      def _add_custom(name:, group:, shell: '/usr/sbin/nologin', home_dir: "/web/#{group}", uid: nil)
+        if (resp = self.adding_validation(name: name, container_name: group)).net_status_ok?
+          container_lib_mapper = @lib.containers.f(group)
+          passwd_mapper = container_lib_mapper.config.f('etc-passwd')
+
+          useradd_command = "useradd #{name} -g #{group} -d #{home_dir} -s #{shell}".split
+          useradd_command += "-u #{uid} -o".split unless uid.nil?
+          self.command!(useradd_command, debug: false)
+
+          user = self._get(name: name)
+
+          self.with_dry_run do |dry_run|
+            user_gid, user_uid = dry_run ? ['XXXX', 'XXXX'] : [user.gid, user.uid]
+            passwd_mapper.append_line!("#{name}:x:#{user_uid}:#{user_gid}::#{home_dir}:#{shell}")
+          end
+        end
+        resp
+      end
+
+      def _pretty_add_custom(name:, group:, shell: '/usr/sbin/nologin', home_dir: "/web/#{group}", uid: nil)
+        self.debug_operation(desc: { code: :user, data: { name: name } }) do |&blk|
+          if self._get(name: name)
+            blk.call(code: :ok)
+            {}
+          else
+            self._add_custom(name: name, group: group, shell: shell, home_dir: home_dir, uid: uid).tap do
+              blk.call(code: :added)
+            end
+          end
+        end
+      end
+
+      def _pretty_del(name:, group:)
+        with_adding_group = self._group_get_users(name: group).one? ? true : false
+        self._del(name: name)
+        self._group_add(name: group) if with_adding_group
+      end
+
+      def _del(name:)
+        self.debug_operation(desc: { code: :user, data: { name: name } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            resp = {}
+            resp = self.command!("userdel #{name}", debug: false) unless dry_run
+            blk.call(code: :deleted)
+            resp
+          end
+        end
+      end
 
+      def _create_password(generate: false)
+        password = if generate
+          SecureRandom.hex
+        else
+          while 1
+            if (pass = ask('Enter password: ') { |q| q.echo = false }) != ask('Repeat password: ') { |q| q.echo = false }
+              self.info('Passwords does not match')
+            elsif !StrongPassword::StrengthChecker.new(pass).is_strong?(min_entropy: @config.f('password_strength', default: '15').to_i)
+              self.info('Password is weak')
+            else
+              break
+            end
+          end
+          pass
+        end
+        encrypted_password = UnixCrypt::SHA512.build(password)
+        { password: password, encrypted_password: encrypted_password }
       end
 
-      def change(name:, container_name:, no_ssh: false, no_ftp: false)
+      def _update_password(name:, encrypted_password:)
+        self.debug_operation(desc: { code: :user, data: { name: name } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            resp = {}
+            resp = self.command!("usermod -p '#{encrypted_password}' #{name}", debug: false) unless dry_run
+            blk.call(code: :updated)
+            resp
+          end
+        end
+      end
+
+      def _group_get(name:)
+        begin
+          Etc.getgrnam(name)
+        rescue ArgumentError => e
+          nil
+        end
+      end
+
+      def _group_add(name:)
+        self.debug_operation(desc: { code: :group, data: { name: name } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            resp = {}
+            resp = self.command!("groupadd #{name}", debug: false) unless dry_run
+            blk.call(code: :added)
+            resp
+          end
+        end
+      end
+
+      def _group_pretty_add(name:)
+        self._group_add(name: name) if self._group_get(name: name).nil?
+      end
+
+      def _group_del(name:)
+        self.debug_operation(desc: { code: :group, data: { name: name } }) do |&blk|
+          self.with_dry_run do |dry_run|
+            resp = {}
+            resp = self.command!("groupdel #{name}", debug: false) unless dry_run
+            blk.call(code: :deleted)
+            resp
+          end
+        end
+      end
+
+      def _group_pretty_del(name:)
+        self._group_del(name: name) unless self._group_get(name: name).nil?
+      end
+
+      def _group_get_users(name:)
+        if (group = self._group_get(name: name))
+          gid = group.gid
+
+          users = []
+          Etc.passwd do |user|
+            users << user if user.gid == gid
+          end
+          users
+        else
+          []
+        end
+      end
+
+      def _group_get_users_names(name:)
+        self._group_get_users(name: name).map(&:name)
+      end
+
+      def _group_get_system_users(name:)
+        if (base_user = self._get(name: name))
+          self._group_get_users(name: name).map {|u| u.name.slice(/(?<=#{name}_).*/) if u.uid != base_user.uid }.compact
+        else
+          []
+        end
+      end
+
+      def _group_del_users(name:)
+        self._group_get_users_names(name: name).each {|user| self._del(name: user) }
+      end
+
+      def adding_validation(name:, container_name:)
+        return { error: :input_error, code: :invalid_user_name, data: { name: name, regex: USER_NAME_FORMAT } } if name !~ USER_NAME_FORMAT
+        self.not_existing_validation(name: name, container_name: container_name)
+      end
+
+      def existing_validation(name:, container_name:)
+        user_name = "#{container_name}_#{name}"
+        PathMapper.new('/etc/passwd').check(user_name) ? {} : { error: :logical_error, code: :user_does_not_exists, data: { name: user_name } }
+      end
 
+      def not_existing_validation(name:, container_name:)
+        self.existing_validation(name: name, container_name: container_name).net_status_ok? ? { error: :logical_error, code: :user_exists, data: { name: "#{container_name}_#{name}" } } : {}
       end
     end
   end