superhosting 0.0.1 → 0.0.2

data/lib/superhosting/config_executor.rb

@@ -0,0 +1,12 @@
+module Superhosting
+  module ConfigExecutor
+    def self.new(**kwargs)
+      klass = if kwargs[:site].nil?
+        Container
+      else
+        Site
+      end
+      klass.new(kwargs)
+    end
+  end
+end

data/lib/superhosting/{script_executor → config_executor}/base.rb

@@ -1,12 +1,12 @@
 module Superhosting
-  module ScriptExecutor
+  module ConfigExecutor
     class Base
       include Helpers
 
       attr_accessor :commands
-      attr_accessor :model, :lib, :config
+      attr_accessor :model, :lib, :etc, :docker_api
 
-      def initialize(model:, lib:, config:, **kwargs)
+      def initialize(model:, lib:, etc:, docker_api:, **kwargs)
         kwargs.each do |k, v|
           instance_variable_set("@#{k}", v)
           self.class.class_eval("attr_accessor :#{k}")
@@ -15,11 +15,12 @@ module Superhosting
         self.commands = []
         self.model = model
         self.lib = lib
-        self.config = config
+        self.etc = etc
+        self.docker_api = docker_api
       end
 
       def execute(script)
-        self.instance_eval(script)
+        self.instance_eval(script, script.path.to_s)
       end
     end
   end

data/lib/superhosting/config_executor/container.rb

@@ -0,0 +1,69 @@
+module Superhosting
+  module ConfigExecutor
+    class Container < Base
+      attr_accessor :container, :mux, :mux_name, :registry_files
+
+      def initialize(container:, on_reconfig:, on_config:, mux: nil, **kwargs)
+        self.container = container
+        self.mux = mux
+        self.mux_name = mux.nil? ? mux : "mux-#{mux.name}"
+        self.registry_files = []
+        @on_config = on_config
+        @on_reconfig = on_reconfig
+        super(**kwargs)
+      end
+
+      def mkdir(path, **options)
+        if @on_config
+          PathMapper.new(path).create!
+          self.set_file_attributes(path, options)
+          self.registry_files << path.to_s
+        end
+      end
+
+      def config(save_to, script=nil, **options)
+        if @on_config
+          save_to_mapper = PathMapper.new(save_to)
+          script = options.delete(:source) || save_to_mapper.name if script.nil?
+          script = script.to_s.end_with?('.erb') ? script : "#{script}.erb"
+          raise NetStatus::Exception.new(error: :error, code: :can_not_pass_an_absolute_path, data: { path: script }) if Pathname.new(script).absolute?
+          script_mapper = self.config_mapper(options).config_templates.f(script)
+          raise NetStatus::Exception.new(error: :error, code: :file_does_not_exists, data: { path: script_mapper.path.to_s }) if script_mapper.nil?
+          save_to_mapper.put!(script_mapper)
+          self.set_file_attributes(save_to_mapper.path, options)
+          self.registry_files << save_to_mapper.path.to_s
+        end
+      end
+
+      def on_reconfig(cmd)
+        self.commands << cmd if @on_reconfig
+      end
+
+      def run_commands
+        self.commands.each do |cmd|
+          if cmd == :container_restart
+            self.container.lib.signature.delete!(logger: false)
+          else
+            self.command! cmd
+          end
+        end
+      end
+
+      protected
+
+      def set_file_attributes(path, user: nil, group: nil, mode: nil, **kwargs)
+        chown!(user, group, path) if user and group
+        chmod!(mode, path) if user and mode
+      end
+
+      def base_mapper
+        self.container
+      end
+
+      def config_mapper(options)
+        self.base_mapper.erb_options = instance_variables_to_hash(self).merge(options)
+        self.base_mapper
+      end
+    end
+  end
+end

data/lib/superhosting/config_executor/site.rb

@@ -0,0 +1,18 @@
+module Superhosting
+  module ConfigExecutor
+    class Site < Container
+      attr_accessor :site
+
+      def initialize(site:, **kwargs)
+        self.site = site
+        super(**kwargs)
+      end
+
+      protected
+
+      def base_mapper
+        self.site
+      end
+    end
+  end
+end

data/lib/superhosting/controller/admin.rb

@@ -1,20 +1,100 @@
 module Superhosting
   module Controller
     class Admin < Base
-      def add(name:)
+      def initialize(**kwargs)
+        super(**kwargs)
+        @admins_mapper = @config.admins
+      end
+
+      def list
+        admins = {}
+        @admins_mapper.grep_dirs.map do |dir_name|
+          admin_name = dir_name.name
+
+          container_admin_controller = self.get_controller(Admin::Container, name: admin_name)
+          if (resp = container_admin_controller.list).net_status_ok?
+            admins[admin_name] = resp[:data]
+          else
+            return resp
+          end
+        end
+
+        { data: admins }
+      end
 
+      def add(name:, generate: false)
+        if (resp = self.not_existing_validation(name: name)).net_status_ok?
+          admin_dir = @admins_mapper.f(name)
+          admin_dir.create!
+          admin_dir.passwd.put!(name)
+          self.reindex_admin(name: name)
+          self.command!("chmod 640 #{admin_dir.path}")
+          self.passwd(name: name, generate: generate)
+        else
+          resp
+        end
       end
 
       def delete(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          admin_container_controller = self.get_controller(Admin::Container, name: name)
+          if (resp = admin_container_controller._delete_all_users).net_status_ok?
+            admin_dir = @admins_mapper.f(name)
+            admin_dir.delete!
+            self.reindex_admin(name: name)
+          end
+        end
+        resp
+      end
+
+      def passwd(name:, generate: false)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          user_controller = self.get_controller(User)
+          admin_dir = @admins_mapper.f(name)
+          passwords = user_controller._create_password(generate: generate)
+          admin_dir.passwd.put!("#{name}:#{passwords[:encrypted_password]}")
+
+          users = self.index[name]
+          users.each do |user_name|
+            user_controller._update_password(name: user_name, encrypted_password: passwords[:encrypted_password])
+          end
 
+          generate ? { data: passwords[:password] } : {}
+        else
+          resp
+        end
       end
 
-      def passwd(name:, generate: nil)
+      def container(name:)
+        self.get_controller(Container, name: name)
+      end
+
+      def existing_validation(name:)
+        (@admins_mapper.f(name)).nil? ? { error: :logical_error, code: :admin_does_not_exists, data: { name: name } } : {}
+      end
+
+      def not_existing_validation(name:)
+        self.existing_validation(name: name).net_status_ok? ? { error: :logical_error, code: :admin_exists, data: { name: name } } : {}
+      end
+
+      def index
+        @@index ||= self.reindex
+      end
 
+      def reindex
+        @@index = {}
+        @admins_mapper.grep_dirs.each {|dir_name| self.reindex_admin(name: dir_name.name) }
+        @@index
       end
 
-      def container(name:, logger: @logger)
-        Container.new(name: name, logger: logger)
+      def reindex_admin(name:)
+        @@index ||= {}
+        if @admins_mapper.f(name).nil?
+          @@index.delete(name)
+        else
+          admin_container_controller = self.get_controller(Admin::Container, name: name)
+          @@index[name] = admin_container_controller._users_list.net_status_ok![:data] || []
+        end
       end
     end
   end

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

@@ -2,21 +2,81 @@ module Superhosting
   module Controller
     class Admin
       class Container < Base
-        def initialize(name:, **kvargs)
+        def initialize(name:, **kwargs)
+          super(kwargs)
           @admin_name = name
-          super(kvargs)
+          @user_controller = self.get_controller(User)
+          @admin_controller = self.get_controller(Admin)
+          @container_controller = self.get_controller(Controller::Container)
+          @admin_passwd = @config.admins.f(@admin_name).passwd
+
+          @admin_controller.existing_validation(name: @admin_name).net_status_ok!
         end
 
         def list
+          containers = @container_controller._list
+          container_users = containers.map do |container_name, data|
+            unless @user_controller._get(name: "#{container_name}_admin_#{@admin_name}").nil?
+              { container: container_name, user: "#{container_name}_admin_#{@admin_name}" }
+            end
+          end.compact
 
+          { data: container_users }
         end
 
         def add(name:)
+          admin_name = "admin_#{@admin_name}"
 
+          if (resp = @container_controller.available_validation(name: name)).net_status_ok? and
+              (resp = @user_controller.not_existing_validation(name: admin_name, container_name: name)).net_status_ok?
+            user, encrypted_password = @admin_passwd.split(':')
+            if (resp = @user_controller._add(name: admin_name, container_name: name, shell: '/bin/bash')).net_status_ok?
+              resp = encrypted_password.nil? ? {} : @user_controller._update_password(name: "#{name}_#{admin_name}", encrypted_password: encrypted_password)
+            end
+          end
+          resp
         end
 
         def delete(name:)
+          admin_name = "admin_#{@admin_name}"
+
+          if (resp = @container_controller.available_validation(name: name)).net_status_ok? and
+              (resp = @user_controller.existing_validation(name: admin_name, container_name: name)).net_status_ok?
+            resp = @user_controller.delete(name: admin_name, container_name: name)
+          end
+          resp
+        end
+
+        def _containers_list
+          if (resp = self.list).net_status_ok?
+            containers = resp[:data].map {|elm| elm[:container] }
+            { data: containers }
+          else
+            resp
+          end
+        end
+
+        def _users_list
+          if (resp = self.list).net_status_ok?
+            users = resp[:data].map {|elm| elm[:user] }
+            { data: users }
+          else
+            resp
+          end
+        end
 
+        def _delete_all_users
+          if (resp = self._containers_list).net_status_ok?
+            containers = resp[:data]
+            containers.each do |container_name|
+              unless (resp = self.delete(name: container_name)).net_status_ok?
+                return resp
+              end
+            end
+            {}
+          else
+            resp
+          end
         end
       end
     end

data/lib/superhosting/controller/base.rb

@@ -0,0 +1,18 @@
+module Superhosting
+  module Controller
+    class Base < Base
+      def repair
+        container_controller = self.get_controller(Container)
+        container_controller.index.each do |container_name, hash_of_mappers|
+          if hash_of_mappers[:state_mapper].value != 'up'
+            container_controller.reconfigure(name: container_name).net_status_ok!
+          else
+            container_controller._each_site(name: container_name) do |controller, name, state|
+              controller.reconfigure(name: name).net_status_ok! if state != 'up'
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/superhosting/controller/container.rb

@@ -1,173 +1,236 @@
 module Superhosting
   module Controller
     class Container < Base
-      CONTAINER_NAME_FORMAT = /[a-zA-Z0-9][a-zA-Z0-9_.-]+/
+      CONTAINER_NAME_FORMAT = /^[a-zA-Z0-9][a-zA-Z0-9_.-]+$/
+
+      def initialize(**kwargs)
+        super
+        self.index
+      end
 
       def list
-        docker = @docker_api.container_list.map {|c| c['Names'].first.slice(1..-1) }.to_set
-        sx = @config.containers._grep_dirs.map {|n| n._name }.to_set
-        containers = (docker & sx)
+        # TODO
+        # docker = @docker_api.container_list.map {|c| c['Names'].first.slice(1..-1) }.to_set
+        # sx = @config.containers.grep_dirs.map {|n| n.name }.compact.to_set
+        # containers = (docker & sx)
 
-        { data: containers.to_a }
+        containers = self._list
+        { data: containers }
       end
 
-      def add(name:, mail: 'model', admin_mail: nil, model: nil)
-        return { error: :input_error, message: "Invalid container name '#{name}' - only '#{CONTAINER_NAME_FORMAT}' are allowed" } if name !~ CONTAINER_NAME_FORMAT
-        return { error: :logical_error, message: 'Container already running.' } if @docker_api.container_info(name)
-        return { error: :input_error, message: 'No model given.' } unless (model_ = model || @config.default_model(default: nil))
-
-        # config
-        config_path_ = "#{@config_path}/containers/#{name}"
-        config_path_mapper = PathMapper.new(config_path_)
-        FileUtils.mkdir_p config_path_
-
-        # model
-        create_conf("#{config_path_}/model", model) unless model.nil?
-        model_mapper = @config.models.f(:"#{model_}")
-
-        # image
-        return { error: :input_error, message: "No docker_image specified in model '#{model_}.'" } unless (image = model_mapper.docker_image(default: nil))
-
-        # mail
-        unless mail != 'no'
-          if mail == 'yes'
-            create_conf("#{config_path_}/mail", mail)
-            admin_mail_ = admin_mail
-            create_conf("#{config_path_}/admin_mail", admin_mail_) unless admin_mail_.nil?
-            return { error: :input_error, message: 'Admin mail required.' } if admin_mail_.nil?
-          elsif mail == 'model'
-            if model_mapper.default_mail == 'yes'
-              admin_mail_ = admin_mail || model_mapper.default_admin_mail(default: nil)
-              return { error: :input_error, message: 'Admin mail required.' } if admin_mail_.nil?
-            end
-          end
+      def _list
+        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 }
         end
 
-        # lib
-        lib_path_ = "#{@lib_path}/containers/#{name}"
-        lib_path_mapper = PathMapper.new(lib_path_)
-        FileUtils.rm_rf "#{lib_path_}/configs"
-        FileUtils.mkdir_p "#{lib_path_}/configs"
-        FileUtils.mkdir_p "#{lib_path_}/web"
-
-        # user/group
-        self.command("groupadd #{name}")
-        self.command("useradd #{name} -g #{name} -d #{lib_path_}/web/")
+        containers = {}
+        @config.containers.grep_dirs.map do |n|
+          name = n.name
+          user_controller = self.get_controller(User)
+          containers[name] = {
+              state: self.state(name: name).value,
+              users: user_controller._list(container_name: name),
+              admins: self.admin(name: name)._list
+          }.merge(data(name)) if self.index.key? name and self.index[name][:mapper].lib.state.file?
+        end
+        containers
+      end
 
-        user = Etc.getpwnam(name)
+      def inspect(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          { data: self._list[name] }
+        else
+          resp
+        end
+      end
 
-        write_if_not_exist("#{lib_path_}/configs/etc-group", "#{name}:x:#{user.gid}:")
-        write_if_not_exist("#{lib_path_}/configs/etc-passwd", "#{name}:x:#{user.uid}:#{user.gid}::/web/:/usr/sbin/nologin")
+      def add(name:, mail: 'model', admin_mail: nil, model: nil)
+        resp = self._reconfigure(name: name, mail: mail, admin_mail: admin_mail, model: model) if (resp = self.not_existing_validation(name: name)).net_status_ok?
+        resp
+      end
 
-        # system users
-        users = [config_path_mapper.system_users, model_mapper.system_users].find {|f| f.is_a? PathMapper::FileNode }
-        users.lines.each {|u| self.command("useradd #{name}_#{u.strip} -g #{name} -d #{lib_path_}/web/") } unless users.nil?
+      def delete(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          lib_mapper = @lib.containers.f(name)
+
+          states = {
+              up: { action: :stop, undo: :run, next: :configuration_applied },
+              configuration_applied: { action: :unconfigure_with_unapply, undo: :configure_with_apply, next: :mux_runned },
+              mux_runned: { action: :stop_mux, undo: :run_mux, next: :users_installed },
+              users_installed: { action: :uninstall_users, next: :data_installed },
+              data_installed: { action: :uninstall_data }
+          }
+
+          self.on_state(state_mapper: lib_mapper, states: states,
+                        name: name)
+        end
+        resp
+      end
 
-        # services
-        cserv = @config.containers.f(name).services._grep(/.*\.erb/).map {|n| [n._name, n]}.to_h
-        mserv = model_mapper.services._grep(/.*\.erb/).map {|n| [n._name, n]}.to_h
-        services = mserv.merge!(cserv)
+      def change(name:, mail: 'model', admin_mail: nil, model: nil)
 
-        supervisor_path = "#{lib_path_}/supervisor"
-        FileUtils.mkdir_p supervisor_path
-        services.each do |_name, node|
-          text = erb(node, model: model_, container: config_path_mapper)
-          create_conf("#{supervisor_path}/#{_name[/.*[^\.erb]/]}", text)
-        end
+      end
 
-        # container
-        unless model_mapper.f('container.rb').nil?
-          registry_path = lib_path_mapper.registry.f('container')._path
-          ex = ScriptExecutor::Container.new(
-              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('container.rb'))
-          ex.commands.each {|c| self.command c }
+      def update(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok? and @docker_api.container_exists?(name)
+          mapper = self.index[name][:mapper]
+          image = mapper.lib.image.value
+          self._recreate_docker(name: name) unless @docker_api.container_image?(name, image)
         end
+        resp
+      end
 
-        # docker
-        write_if_not_exist('/etc/security/docker.conf', "@#{name} #{name}")
+      def rename(name:, new_name:)
+        if (resp = self.available_validation(name: name)).net_status_ok? and
+            (resp = self.adding_validation(name: new_name)).net_status_ok?
 
-        # run container
-        self.command "docker run --detach --name #{name} -v #{lib_path_}/configs/:/.configs:ro
-                      -v #{lib_path_}/web:/web #{image} /usr/bin/supervisord -n -c /etc/supervisor/supervisord.conf".split
+          mapper = self.index[name][:mapper]
+          new_etc_mapper = mapper.etc.parent.f(new_name)
+          model = nil if (model = mapper.f('model').value).nil? # TODO: mail:, admin_mail:
 
-        { error: :error, message: 'Unable to run docker container.' } unless @docker_api.container_info(name)
-      end
+          mapper.rename!(new_etc_mapper.path)
+          mapper.create!
 
-      def delete(name:)
-        config_path_mapper = @config.containers.f(name)
-        lib_path_mapper = PathMapper.new("#{@lib_path}/containers/#{name}")
-        model = config_path_mapper.model(default: @config.default_model)
-        model_mapper = @config.models.f(:"#{model}")
-
-        sites = config_path_mapper.sites._grep_dirs.map { |n| n._name }
-        sites.each do |s|
           begin
-            Site.new(instance_variables_to_hash(self)).delete(s)
-          rescue NetStatus::Exception => e
-            raise Error::Controller, e.net_status
+            self.stop(name: name).net_status_ok!
+            self.unconfigure_with_unapply(name: name).net_status_ok!
+            if (resp = self._reconfigure(name: new_name, model: model)).net_status_ok?
+              new_mapper = self.index[new_name][:mapper]
+              mapper.lib.web.rename!(new_mapper.lib.web.path)
+              mapper.lib.sites.rename!(new_mapper.lib.sites.path)
+              mapper.lib.registry.sites.rename!(new_mapper.lib.registry.sites.path)
+
+              site_controller = self.get_controller(Site)
+              site_controller.reindex_container_sites(container_name: new_name)
+              site_controller.reindex_container_sites(container_name: name)
+
+              self.reconfigure(name: new_name).net_status_ok!
+              self.delete(name: name).net_status_ok!
+            end
+          rescue Exception => e
+            resp = e.net_status
+            raise
+          ensure
+            unless resp.net_status_ok?
+              unless new_mapper.nil?
+                new_mapper.lib.web.rename!(mapper.lib.web.path)
+                new_mapper.lib.sites.rename!(mapper.lib.sites.path)
+                new_etc_mapper.rename!(mapper.path)
+                self.reconfigure(name: name)
+              end
+              self.delete(name: new_name)
+            end
           end
         end
+        resp
+      end
 
-        unless (container = lib_path_mapper.registry.f('container')).nil?
-          FileUtils.rm container.lines
-          FileUtils.rm container._path
+      def reconfigure(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          self.set_state(name: name, state: :data_installed)
+          resp = self._reconfigure(name: name)
         end
+        resp
+      end
 
-        unless model_mapper.f('container.rb').nil?
-          registry_path = lib_path_mapper.registry.f('container')._path
-          ex = ScriptExecutor::Container.new(
-              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('container.rb'))
-          ex.commands.each {|c| self.command c }
-        end
+      def _reconfigure(name:, **kwargs)
+        lib_mapper = @lib.containers.f(name)
 
-        @docker_api.container_kill(name)
-        @docker_api.container_rm(name)
-        remove_line_from_file('/etc/security/docker.conf', "@#{name} #{name}")
+        states = {
+            none: { action: :install_data, undo: :uninstall_data, next: :data_installed },
+            data_installed: { action: :install_users, undo: :uninstall_users, next: :users_installed },
+            users_installed: { action: :run_mux, undo: :stop_mux, next: :mux_runned },
+            mux_runned: { action: :configure_with_apply, undo: :unconfigure_with_unapply, next: :configuration_applied },
+            configuration_applied: { action: :run, undo: :stop, next: :up }
+        }
 
-        begin
-          gid = Etc.getgrnam(name).gid
-          Etc.passwd do |user|
-            self.command("userdel #{user.name}") if user.gid == gid
-          end
-          self.command("groupdel #{name}")
-        rescue ArgumentError => e
-          # repeated command execution: group name already does not exist
-        end
+        self.on_state(state_mapper: lib_mapper, states: states,
+                      name: name, **kwargs)
+      end
 
-        FileUtils.rm_rf "#{@lib_path}/containers/#{name}/configs"
+      def save(name:, to:)
 
-        {}
       end
 
-      def change(name:, mail: 'model', admin_mail: nil, model: nil)
+      def restore(name:, from:, mail: 'model', admin_mail: nil, model: nil)
 
       end
 
-      def update(name:)
+      def admin(name:)
+        self.get_controller(Admin, name: name)
+      end
 
+      def base_validation(name:)
+        @docker_api.container_rm_inactive!(name)
+        (name !~ CONTAINER_NAME_FORMAT) ? { error: :input_error, code: :invalid_container_name, data: { name: name, regex: CONTAINER_NAME_FORMAT } } : {}
       end
 
-      def reconfig(name:)
+      def adding_validation(name:)
+        if (resp = self.base_validation(name: name)).net_status_ok?
+          resp = self.not_running_validation(name: name)
+        end
+        resp
+      end
 
+      def running_validation(name:)
+        @docker_api.container_running?(name) ? {}: { error: :logical_error, code: :container_is_not_running, data: { name: name } }
       end
 
-      def save(name:, to:)
+      def not_running_validation(name:)
+        @docker_api.container_not_running?(name) ? {} : { error: :logical_error, code: :container_is_running, data: { name: name } }
+      end
 
+      def existing_validation(name:)
+        self.index.include?(name) ? {} : { error: :logical_error, code: :container_does_not_exists, data: { name: name }  }
       end
 
-      def restore(name:, from:, mail: 'model', admin_mail: nil, model: nil)
+      def not_existing_validation(name:)
+        self.existing_validation(name: name).net_status_ok? ? { error: :logical_error, code: :container_exists, data: { name: name }  } : {}
+      end
+
+      def available_validation(name:)
+        if (resp = self.existing_validation(name: name)).net_status_ok?
+          resp = (self.index[name][:mapper].lib.state.value == 'up') ? {} : { error: :logical_error, code: :container_is_not_available, data: { name: name }  }
+        end
+        resp
+      end
 
+      def index
+        @@index ||= self.reindex
       end
 
-      def admin(name:, logger: @logger)
-        Admin.new(name: name, logger: logger)
+      def reindex
+        @config.containers.grep_dirs.each {|mapper| self.reindex_container(name: mapper.name) }
+        @@index ||= {}
+      end
+
+      def reindex_container(name:)
+        @@index ||= {}
+        etc_mapper = @config.containers.f(name)
+        web_mapper = PathMapper.new('/web').f(name)
+        lib_mapper = @lib.containers.f(name)
+        state_mapper = lib_mapper.state
+
+        if etc_mapper.nil?
+          @@index.delete(name)
+          return
+        end
+
+        model_name = etc_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 = { container: mapper }
+        mux_mapper = if (mux_file_mapper = etc_mapper.mux).file?
+          MapperInheritance::Mux.new(@config.muxs.f(mux_file_mapper)).set_inheritors
+        end
+
+        @@index[name] = { mapper: mapper, mux_mapper: mux_mapper, state_mapper: state_mapper }
       end
     end
   end