Merge pull request #3 from viniciusfdasilva/dev

Change test.yml

.github/workflows/test.yml

@@ -0,0 +1,29 @@
+name: Danix File System
+
+on: 
+  pull_request:
+    branches: [main]
+  push:
+    branches: [dev]
+
+jobs:
+  continuous-integration:
+    runs-on: ubuntu-latest
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v3
+      
+      - name: Python
+        uses: actions/setup-python@v2
+        with:
+          python-version: "3.10"
+      
+      - name: Install danix
+        shell: bash
+        run: |
+          cd danix
+          sudo apt install make -y
+          sudo make install
+          sudo python /usr/share/danix/main.py --help
+

.gitignore

@@ -6,6 +6,7 @@ __pycache__/
 # C extensions
 *.so
 
+.obsidian
 # Distribution / packaging
 .Python
 build/

.obsidian/app.json

@@ -1 +0,0 @@
-{}

.obsidian/appearance.json

@@ -1,3 +0,0 @@
-{
-  "accentColor": ""
-}

.obsidian/core-plugins-migration.json

@@ -1,29 +0,0 @@
-{
-  "file-explorer": true,
-  "global-search": true,
-  "switcher": true,
-  "graph": true,
-  "backlink": true,
-  "canvas": true,
-  "outgoing-link": true,
-  "tag-pane": true,
-  "page-preview": true,
-  "daily-notes": true,
-  "templates": true,
-  "note-composer": true,
-  "command-palette": true,
-  "slash-command": false,
-  "editor-status": true,
-  "bookmarks": true,
-  "markdown-importer": false,
-  "zk-prefixer": false,
-  "random-note": false,
-  "outline": true,
-  "word-count": true,
-  "slides": false,
-  "audio-recorder": false,
-  "workspaces": false,
-  "file-recovery": true,
-  "publish": false,
-  "sync": false
-}

.obsidian/core-plugins.json

@@ -1,20 +0,0 @@
-[
-  "file-explorer",
-  "global-search",
-  "switcher",
-  "graph",
-  "backlink",
-  "canvas",
-  "outgoing-link",
-  "tag-pane",
-  "page-preview",
-  "daily-notes",
-  "templates",
-  "note-composer",
-  "command-palette",
-  "editor-status",
-  "bookmarks",
-  "outline",
-  "word-count",
-  "file-recovery"
-]

.obsidian/hotkeys.json

@@ -1 +0,0 @@
-{}

.obsidian/workspace.json

@@ -1,175 +0,0 @@
-{
-  "main": {
-    "id": "683db9948478d0f5",
-    "type": "split",
-    "children": [
-      {
-        "id": "a905c00f12ba46a8",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "9dc0c2825057834f",
-            "type": "leaf",
-            "state": {
-              "type": "markdown",
-              "state": {
-                "file": "README.md",
-                "mode": "source",
-                "source": false
-              }
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "vertical"
-  },
-  "left": {
-    "id": "7e868bf1b448074e",
-    "type": "split",
-    "children": [
-      {
-        "id": "8fca1960ef31b421",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "25fbe0fcd9c25fd0",
-            "type": "leaf",
-            "state": {
-              "type": "file-explorer",
-              "state": {
-                "sortOrder": "alphabetical"
-              }
-            }
-          },
-          {
-            "id": "dff4013cf8dfedc3",
-            "type": "leaf",
-            "state": {
-              "type": "search",
-              "state": {
-                "query": "",
-                "matchingCase": false,
-                "explainSearch": false,
-                "collapseAll": false,
-                "extraContext": false,
-                "sortOrder": "alphabetical"
-              }
-            }
-          },
-          {
-            "id": "83bfd13d38d5b76d",
-            "type": "leaf",
-            "state": {
-              "type": "bookmarks",
-              "state": {}
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "horizontal",
-    "width": 300
-  },
-  "right": {
-    "id": "d0b0379d5ff97957",
-    "type": "split",
-    "children": [
-      {
-        "id": "2f341c12d53e65aa",
-        "type": "tabs",
-        "children": [
-          {
-            "id": "b32b580e05d21b5c",
-            "type": "leaf",
-            "state": {
-              "type": "backlink",
-              "state": {
-                "file": "README.md",
-                "collapseAll": false,
-                "extraContext": false,
-                "sortOrder": "alphabetical",
-                "showSearch": false,
-                "searchQuery": "",
-                "backlinkCollapsed": false,
-                "unlinkedCollapsed": true
-              }
-            }
-          },
-          {
-            "id": "bbfc208669b9169d",
-            "type": "leaf",
-            "state": {
-              "type": "outgoing-link",
-              "state": {
-                "file": "README.md",
-                "linksCollapsed": false,
-                "unlinkedCollapsed": true
-              }
-            }
-          },
-          {
-            "id": "621cfddeb8f85c0a",
-            "type": "leaf",
-            "state": {
-              "type": "tag",
-              "state": {
-                "sortOrder": "frequency",
-                "useHierarchy": true
-              }
-            }
-          },
-          {
-            "id": "4d5cce8fb3df8ab2",
-            "type": "leaf",
-            "state": {
-              "type": "outline",
-              "state": {
-                "file": "README.md"
-              }
-            }
-          }
-        ]
-      }
-    ],
-    "direction": "horizontal",
-    "width": 300,
-    "collapsed": true
-  },
-  "left-ribbon": {
-    "hiddenItems": {
-      "switcher:Open quick switcher": false,
-      "graph:Open graph view": false,
-      "canvas:Create new canvas": false,
-      "daily-notes:Open today's daily note": false,
-      "templates:Insert template": false,
-      "command-palette:Open command palette": false
-    }
-  },
-  "active": "9dc0c2825057834f",
-  "lastOpenFiles": [
-    "img/logo.png",
-    "img/img_vi.png",
-    "img/img_v.png",
-    "img/img_iv.png",
-    "img/img_iii.png",
-    "img/img_ii.png",
-    "img/img_i.png",
-    "img",
-    "danix/wsgi.py",
-    "danix/utils.py",
-    "danix/templates.py",
-    "danix/settings.py",
-    "danix/requirements.txt",
-    "danix/manage.py",
-    "danix/main.py",
-    "danix/db/models.py",
-    "danix/db/migrations/__init__.py",
-    "Pasted image 20230516121302.png",
-    "README.md",
-    "img/img.vi.png",
-    "Pasted image 20230516120949.png",
-    "example.png.md",
-    "logo.png.md"
-  ]
-}

README.md

@@ -3,13 +3,13 @@
 </html>
 
 * Author: Vinicius F. da Silva
-* Version 0.1
+* Version 0.1.4
 * Released: 2023
 
 A very simple subsystem builder!
 
 The Danixfs is a root filesystem management! Build a Alpine subsystem and pre install
-essentials packages and compiers from languanges choice by user: 
+essentials packages and compilers from languages choice by user: 
 # Image:
 
 #### Building a clike environment
@@ -31,13 +31,19 @@ essentials packages and compiers from languanges choice by user:
     * tar 1.34 or higher 
     * python3 or higher
     * pip3 or higher
-# Run Danix
+    * python-is-python3
+# Install Danix
 
-```shell 
+```shell
-$ sudo make config
+$ cd danixfs
 ```
 
-To clean configuracion run:
+
+```shell 
+$ sudo make install
+```
+
+To clean configuration run:
 
 ```shell
 $ sudo make clean
@@ -49,12 +55,17 @@ $ danix -h
 
 ![](./img/img_vi.png)
 
+# Remove Danix
 
+To remove danix run:
+```shell
+$ sudo danixclean
+```
 # Common erros
 
 ![](./img/img_vii.png)
 
-To fix this erro open file *registry.py* located in /usr/local/lib/python3.10/dist-packages/django/apps/
+To fix this problem open file *registry.py*
 
 Search for 
 
@@ -62,10 +73,30 @@ Search for
 raise RuntimeError("populate() isn't reentrant")" 
 ```
 
-line. And replace for following code:
+line. And replace by following code:
 
 ```python
 self.app_configs = {}
 ```
 
-Save file and try again
+Save file and run
+
+
+```shell
+$ sudo make clean
+```
+
+
+```shell
+$ sudo make install
+```
+
+```shell
+$ sudo make aliases
+```
+
+Close terminal, open again and run
+
+```shell
+$ danix --help
+```

danix/danixfs.py

@@ -1,6 +1,8 @@
 import os, settings, app
 from sh import du
 from settings import MAIN_REPO
+from utils import download_checksum, validate_checksum
+from utils import get_message, check_equal_sentence as equals, generate_checksum, remove_checksum_files
 class Danix():
 
     @staticmethod
@@ -17,40 +19,51 @@ class Danix():
 
     @staticmethod
     def rm(filesystem_name):
-        return os.system(f"rm -r {MAIN_REPO}{filesystem_name} >/dev/null 2>&1")
+
+        return os.system(f"rm -r {MAIN_REPO}{filesystem_name}")
 
     @staticmethod
     def get_size(environment_name, snapshot_name):
         try:
+
             if snapshot_name is None:
-                return du(f'{MAIN_REPO}{environment_name}/','-ch').split('\n')[-2].split('\t')[0]
+                return du(
+                            f'{MAIN_REPO}{environment_name}/',f'-ch', 
+                            f'--exclude={MAIN_REPO}{environment_name}/danixfs/proc/*', 
+                            f'--exclude={MAIN_REPO}{environment_name}/danixfs/dev/*', 
+                            f'--exclude={MAIN_REPO}{environment_name}/danixfs/sys/*'
+                        ).split('\n')[-2].split('\t')[0]
             else:
                 return du(f'{MAIN_REPO}.snapshots/{snapshot_name}/{environment_name}.tar.gz','-ch').split('\n')[-2].split('\t')[0]
-        except Exception:
+        except Exception as e:
+            print(e)
             return "00M"
         
     @staticmethod
     def make_snapshot(filesystem_name, snapshot_name):
 
         os.system(f"mkdir {MAIN_REPO}.snapshots/{snapshot_name} >/dev/null 2>&1")
-        resp = os.system(f"tar czf {MAIN_REPO}.snapshots/{snapshot_name}/{filesystem_name}.tar.gz {MAIN_REPO}{filesystem_name}/ >/dev/null 2>&1")
+        exclude_proc_dir = f"{MAIN_REPO}{filesystem_name}/danixfs/proc/*"
+        exclude_sys_dir  = f"{MAIN_REPO}{filesystem_name}/danixfs/sys/*"
+        exclude_dev_dir  = f"{MAIN_REPO}{filesystem_name}/danixfs/dev/*"
+
+        resp = os.system(f"tar -czf {MAIN_REPO}.snapshots/{snapshot_name}/{filesystem_name}.tar.gz --exclude={exclude_proc_dir} --exclude={exclude_dev_dir} --exclude={exclude_sys_dir} {MAIN_REPO}{filesystem_name}/ >/dev/null 2>&1")
         
         return resp
     
     @staticmethod
     def back_snapshot(filesystem_name, snapshot_name):
 
-        os.system(f"rm -r {MAIN_REPO}{filesystem_name} > /dev/null")  
+        Danix.rm(filesystem_name)
         resp1 = os.system(f"tar -xf {MAIN_REPO}.snapshots/{snapshot_name}/{filesystem_name}.tar.gz -C {MAIN_REPO} >/dev/null 2>&1")
-        resp2 = os.system(f"mv {MAIN_REPO}/opt/danix/{filesystem_name} {MAIN_REPO}")
+        resp2 = os.system(f"mv {MAIN_REPO}opt/danix/{filesystem_name} {MAIN_REPO}")
         resp3 = os.system(f"rm -r {MAIN_REPO}opt")
 
         return 0 if resp1+resp2+resp3 == 0 else 1
     
     @staticmethod
     def navigate(filesystem_uuid):
-
+        return os.system(f"{MAIN_REPO}{filesystem_uuid}/danixfs/proot -r {MAIN_REPO}{filesystem_uuid}/danixfs/ -w / -0 -b /dev -b /sys -b /proc -b /run sh {MAIN_REPO}init.d/init.sh")
-        return os.system(f"chroot {MAIN_REPO}{filesystem_uuid}/danixfs sh {MAIN_REPO}init.d/init.sh")
 
     @staticmethod
     def build_environment(packages, config_comands, filesystem_uuid):
@@ -58,26 +71,43 @@ class Danix():
 
         os.system(f"mkdir /tmp/{filesystem}")
         os.system(f"curl --silent -LO --output-dir /tmp/{filesystem} {settings.REPO_NAME}/{settings.ROOT_FS}")
-        os.system(f"tar -xf /tmp/{filesystem}/{settings.ROOT_FS} -C /tmp/{filesystem}")
-        os.system(f"rm /tmp/{filesystem}/{settings.ROOT_FS}")
-        os.system(f"mv /tmp/{filesystem} {MAIN_REPO}")
-
-
-        print("\nPlease! Wait a moment!!")
-        print("Building container:")
-        print(f"Installing {len(packages)} packages\n")
-
-        for package in packages:
-            os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add {package}")
-
-        for command in config_comands:
-            os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs {command}")
-
-        os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add fish")
-        os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add ruby")
-        os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs gem install lolcat")
         
-        print(f"Environment builded succesfully!")
+        resp_downloaded_checksum = download_checksum() 
-        print("0 erros reported!")
+        resp_generateed_checksum = generate_checksum(f"/tmp/{filesystem}/{settings.ROOT_FS}")
         
-        Danix.navigate(filesystem)
+        is_downloaded_and_generate = equals(resp_downloaded_checksum, 0) and equals(resp_generateed_checksum, 0)
+        
+        is_valid_checksum = validate_checksum(filesystem)
+
+        remove_checksum_files()
+
+        if is_downloaded_and_generate and is_valid_checksum:
+
+            os.system(f"tar -xf /tmp/{filesystem}/{settings.ROOT_FS} -C /tmp/{filesystem}")
+            os.system(f"rm /tmp/{filesystem}/{settings.ROOT_FS}")
+            os.system(f"mv /tmp/{filesystem} {MAIN_REPO}")
+
+            print("\nPlease! Wait a moment!!")
+            print("Building container:")
+            print(f"Installing {len(packages)} packages\n")
+
+            for command in config_comands:
+                os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs {command}")
+
+            for package in packages:
+                os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add {package}")
+
+            os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add fish")
+            os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs apk add ruby")
+            os.system(f"chroot {MAIN_REPO}{filesystem}/danixfs gem install lolcat")
+
+            os.system(f"rm -r {MAIN_REPO}{filesystem}/danixfs/dev >/dev/null 2>&1")
+            os.system(f"rm -r {MAIN_REPO}{filesystem}/danixfs/proc >/dev/null 2>&1")
+            os.system(f"rm -r {MAIN_REPO}{filesystem}/danixfs/sys >/dev/null 2>&1")
+
+            print(f"Environment builded succesfully!")
+            print("0 erros reported!")
+
+            Danix.navigate(filesystem)
+        else:
+            get_message("🔴 Failed integrity base image verification!", True, 1)

danix/db/models.py

@@ -41,7 +41,7 @@ class Environment(models.Model):
                             )
 
             if check_equal_sentence(resp, 0):
-                get_message("🟢 Elements copyed successfuly!", True, 0)        
+                get_message("🟢 Elements copied successfuly!", True, 0)        
             else:
                 get_message("🔴 Copy error!", True, 1)
         else:
@@ -260,7 +260,12 @@ class Snapshot(models.Model):
                         
                         Snapshot.objects.get(snapshot_name=snapshot.snapshot_name).delete()
 
-                        get_message(message=f"🟢 Snapshot removed successfully - {snapshot.snapshot_name}", is_finishprogram=False, finish_status_code=-1) 
+                        get_message(
+                                message=f"🟢 Snapshot removed successfully - {snapshot.snapshot_name}", 
+                                is_finishprogram=False, 
+                                finish_status_code=-1
+                            )
+                         
                     
                     else:
                         get_message(message="🔴 Error: Snapshot can not remove", is_finishprogram=True, finish_status_code=1) 
@@ -293,8 +298,7 @@ class Snapshot(models.Model):
                     resp = Danix.back_snapshot(filesystem_name, snapshot.snapshot_name)
 
                     if check_equal_sentence(resp, 0):
-                        get_message(message="🟢 Snapshot roll back successfully!", is_finishprogram=True, finish_status_code=0)
+                        get_message(message="🟢 Environment roll back successfully!", is_finishprogram=True, finish_status_code=0)
-
                     get_message(message="🔴 Error: Snapshot can not back", is_finishprogram=True, finish_status_code=1)
 
                 get_message(message="🔴 Error: Environment was removed!", is_finishprogram=True, finish_status_code=1)

danix/main.py

@@ -27,7 +27,7 @@ usages.add_argument("-sc", "--snapshotcreate",      help="Create snapshot", requ
 usages.add_argument("-sb", "--snapshotback"  ,      help="Back snapshot",   required=False)
 usages.add_argument("-c", "--copy"  ,               help="Copy files and directories",   required=False)
 
-usages.add_argument("-o", "--option",   choices=["clike", "java", "python", "ruby", "lua", "go", "ada"], required=False)
+usages.add_argument("-o", "--option",   choices=["clike", "java", "python", "ruby", "lua", "go", "ada", "dotnet", "v"], required=False)
 
 args = parser.parse_args()
 
@@ -38,8 +38,11 @@ languanges_and_softwares = {
                                 "ruby"   : Languanges.Ruby(),
                                 "lua"    : Languanges.Lua(),
                                 "go"     : Languanges.Go(),
-                                "ada"    : Languanges.Ada()
+                                "ada"    : Languanges.Ada(),
+                                "dotnet" : Languanges.Dotnet(),
+                                "v"      : Languanges.VLang()
                             }
+
 if check_system_configuration():
     if args.option:
 
@@ -104,4 +107,4 @@ if check_system_configuration():
         Environment.copy(args.copy)
 else:
     print("🔴 Danix system is not configured!")
-    print("Plase run 'make config'")
+    print("Plase run 'danixclean' after 'danixconfig'\n\n")

danix/makefile

@@ -4,7 +4,7 @@ SNAPSHOT_LIMIT=3
 DB_NAME=db.sqlite3
 MAIN_REPO=/opt/danix/
 ROOT_FS=danixfs.tar.gz
-DANIX_PATH=$(shell pwd)
+DANIX_PATH=/usr/share/danix
 REPO_NAME=https://silvavinicius.com.br/danixfs/
 
 ENV_GENERIC_ERROR=Error!
@@ -14,12 +14,74 @@ ENV_STARTED=Environment started successfully!
 ENV_STOPPED=Environment stopped successfully!
 ENV_STOPPED_ERROR=Error! The environment is stopped!
 ENV_PATTERN_ERROR=Environment name pattern contains in multiples environments
+PYTHON_PATH := $(shell python -c "import sysconfig; print(sysconfig.get_paths()['purelib'])")
+
+install:
+
+ifneq ($(shell id -u), 0)
+
+	@echo "You are not root, run this target as root please"
+	@exit 0
+
+else
+	
+	@mkdir   $(DANIX_PATH) 2>&1
+	@cp -r * $(DANIX_PATH) 2>&1
+
+	@mkdir $(MAIN_REPO) 2>&1
+	@mkdir $(MAIN_REPO)/.snapshots 2>&1
+
+	@touch $(DANIX_PATH)/.env 2>&1
+
+	@echo REPO_NAME=$(REPO_NAME)      >> $(DANIX_PATH)/.env
+	@echo MAIN_REPO=$(MAIN_REPO)      >> $(DANIX_PATH)/.env
+	@echo ROOT_FS=$(ROOT_FS)          >> $(DANIX_PATH)/.env
+	@echo SNAPSHOT_LIMIT=$(SNAPSHOT_LIMIT) >> $(DANIX_PATH)/.env
+	@echo ENV_NOT_FOUND=$(ENV_NOT_FOUND) >> $(DANIX_PATH)/.env
+	@echo ENV_GENERIC_ERROR=$(ENV_GENERIC_ERROR) >> $(DANIX_PATH)/.env
+	@echo ENV_STOPPED_ERROR=$(ENV_STOPPED_ERROR) >> $(DANIX_PATH)/.env
+	@echo ENV_PATTERN_ERROR=$(ENV_PATTERN_ERROR) >> $(DANIX_PATH)/.env
+	@echo ENV_REMOVED=$(ENV_REMOVED) >> $(DANIX_PATH)/.env
+	@echo ENV_STARTED=$(ENV_STARTED) >> $(DANIX_PATH)/.env
+	@echo ENV_STOPPED=$(ENV_STOPPED) >> $(DANIX_PATH)/.env
+	
+	@touch $(DANIX_PATH)/db/$(DB_NAME)
+	@$(PIP) install -r $(DANIX_PATH)/requirements.txt
+	
+	@rm -r $(PYTHON_PATH)/django/apps/registry.py
+	@mv $(DANIX_PATH)/registry.py $(PYTHON_PATH)/django/apps/
+
+	@$(PYTHON) $(DANIX_PATH)/manage.py migrate
+	
+	@echo "Installation successfully!!! Please 'make aliases without' sudo"
+
+endif
+	
+aliases:
+
+	@touch $(HOME)/.danix_aliases
+	@echo "if [ -f $(HOME)/.danix_aliases ]; then" >> $(HOME)/.bashrc 
+	@echo "		. $(HOME)/.danix_aliases" >> $(HOME)/.bashrc
+	@echo "fi" >> $(HOME)/.bashrc
+	@echo alias danix="'sudo python $(DANIX_PATH)/main.py'" >> $(HOME)/.danix_aliases
+	@echo alias danixconfig="'make -C $(DANIX_PATH) config'" >> $(HOME)/.danix_aliases
+	@echo alias danixclean="'make -C $(DANIX_PATH) clean'" >> $(HOME)/.danix_aliases
+
 
 config:
 
+ifneq ($(shell id -u), 0)
+
+	@echo "You are not root, run this target as root please"
+	@exit 0
+
+else
+
 	@mkdir $(MAIN_REPO) > /dev/null 2>&1
 	@mkdir $(MAIN_REPO)/.snapshots > /dev/null 2>&1
 
+	@echo touch $(DANIX_PATH)/.env
+
 	@echo REPO_NAME=$(REPO_NAME)      >> $(DANIX_PATH)/.env
 	@echo MAIN_REPO=$(MAIN_REPO)      >> $(DANIX_PATH)/.env
 	@echo ROOT_FS=$(ROOT_FS)        >> $(DANIX_PATH)/.env
@@ -33,20 +95,17 @@ config:
 	@echo ENV_STOPPED=$(ENV_STOPPED) >> $(DANIX_PATH)/.env
 	
 	@touch $(DANIX_PATH)/db/$(DB_NAME) > /dev/null 2>&1
+
 	@$(PIP) install -r $(DANIX_PATH)/requirements.txt > /dev/null 2>&1
 
 	@$(PYTHON) $(DANIX_PATH)/manage.py migrate
 
-	@echo Danix configured successfully! Please run make aliases
+endif
 
-aliases:
-	@alias sudo='sudo '
-	@alias danix="python main.py"
-	@echo  Please run danix -h or python main.py -h
 
 clean:
 
+
 	@rm -r $(MAIN_REPO) > /dev/null 2>&1
-	@rm $(DANIX_PATH)/db/$(DB_NAME) > /dev/null 2>&1
+	@rm -r $(DANIX_PATH) > /dev/null 2>&1
-	@rm $(DANIX_PATH)/.env
+	@echo Danix cleaned!
-	@echo Danix cleaned!

danix/registry.py

@@ -0,0 +1,437 @@
+import functools
+import sys
+import threading
+import warnings
+from collections import Counter, defaultdict
+from functools import partial
+
+from django.core.exceptions import AppRegistryNotReady, ImproperlyConfigured
+
+from .config import AppConfig
+
+
+class Apps:
+    """
+    A registry that stores the configuration of installed applications.
+
+    It also keeps track of models, e.g. to provide reverse relations.
+    """
+
+    def __init__(self, installed_apps=()):
+        # installed_apps is set to None when creating the main registry
+        # because it cannot be populated at that point. Other registries must
+        # provide a list of installed apps and are populated immediately.
+        if installed_apps is None and hasattr(sys.modules[__name__], "apps"):
+            raise RuntimeError("You must supply an installed_apps argument.")
+
+        # Mapping of app labels => model names => model classes. Every time a
+        # model is imported, ModelBase.__new__ calls apps.register_model which
+        # creates an entry in all_models. All imported models are registered,
+        # regardless of whether they're defined in an installed application
+        # and whether the registry has been populated. Since it isn't possible
+        # to reimport a module safely (it could reexecute initialization code)
+        # all_models is never overridden or reset.
+        self.all_models = defaultdict(dict)
+
+        # Mapping of labels to AppConfig instances for installed apps.
+        self.app_configs = {}
+
+        # Stack of app_configs. Used to store the current state in
+        # set_available_apps and set_installed_apps.
+        self.stored_app_configs = []
+
+        # Whether the registry is populated.
+        self.apps_ready = self.models_ready = self.ready = False
+        # For the autoreloader.
+        self.ready_event = threading.Event()
+
+        # Lock for thread-safe population.
+        self._lock = threading.RLock()
+        self.loading = False
+
+        # Maps ("app_label", "modelname") tuples to lists of functions to be
+        # called when the corresponding model is ready. Used by this class's
+        # `lazy_model_operation()` and `do_pending_operations()` methods.
+        self._pending_operations = defaultdict(list)
+
+        # Populate apps and models, unless it's the main registry.
+        if installed_apps is not None:
+            self.populate(installed_apps)
+
+    def populate(self, installed_apps=None):
+        """
+        Load application configurations and models.
+
+        Import each application module and then each model module.
+
+        It is thread-safe and idempotent, but not reentrant.
+        """
+        if self.ready:
+            return
+
+        # populate() might be called by two threads in parallel on servers
+        # that create threads before initializing the WSGI callable.
+        with self._lock:
+            if self.ready:
+                return
+
+            # An RLock prevents other threads from entering this section. The
+            # compare and set operation below is atomic.
+            if self.loading:
+                # Prevent reentrant calls to avoid running AppConfig.ready()
+                # methods twice.
+                self.app_configs = {}
+		#raise RuntimeError("populate() isn't reentrant")
+            self.loading = True
+
+            # Phase 1: initialize app configs and import app modules.
+            for entry in installed_apps:
+                if isinstance(entry, AppConfig):
+                    app_config = entry
+                else:
+                    app_config = AppConfig.create(entry)
+                if app_config.label in self.app_configs:
+                    raise ImproperlyConfigured(
+                        "Application labels aren't unique, "
+                        "duplicates: %s" % app_config.label
+                    )
+
+                self.app_configs[app_config.label] = app_config
+                app_config.apps = self
+
+            # Check for duplicate app names.
+            counts = Counter(
+                app_config.name for app_config in self.app_configs.values()
+            )
+            duplicates = [name for name, count in counts.most_common() if count > 1]
+            if duplicates:
+                raise ImproperlyConfigured(
+                    "Application names aren't unique, "
+                    "duplicates: %s" % ", ".join(duplicates)
+                )
+
+            self.apps_ready = True
+
+            # Phase 2: import models modules.
+            for app_config in self.app_configs.values():
+                app_config.import_models()
+
+            self.clear_cache()
+
+            self.models_ready = True
+
+            # Phase 3: run ready() methods of app configs.
+            for app_config in self.get_app_configs():
+                app_config.ready()
+
+            self.ready = True
+            self.ready_event.set()
+
+    def check_apps_ready(self):
+        """Raise an exception if all apps haven't been imported yet."""
+        if not self.apps_ready:
+            from django.conf import settings
+
+            # If "not ready" is due to unconfigured settings, accessing
+            # INSTALLED_APPS raises a more helpful ImproperlyConfigured
+            # exception.
+            settings.INSTALLED_APPS
+            raise AppRegistryNotReady("Apps aren't loaded yet.")
+
+    def check_models_ready(self):
+        """Raise an exception if all models haven't been imported yet."""
+        if not self.models_ready:
+            raise AppRegistryNotReady("Models aren't loaded yet.")
+
+    def get_app_configs(self):
+        """Import applications and return an iterable of app configs."""
+        self.check_apps_ready()
+        return self.app_configs.values()
+
+    def get_app_config(self, app_label):
+        """
+        Import applications and returns an app config for the given label.
+
+        Raise LookupError if no application exists with this label.
+        """
+        self.check_apps_ready()
+        try:
+            return self.app_configs[app_label]
+        except KeyError:
+            message = "No installed app with label '%s'." % app_label
+            for app_config in self.get_app_configs():
+                if app_config.name == app_label:
+                    message += " Did you mean '%s'?" % app_config.label
+                    break
+            raise LookupError(message)
+
+    # This method is performance-critical at least for Django's test suite.
+    @functools.lru_cache(maxsize=None)
+    def get_models(self, include_auto_created=False, include_swapped=False):
+        """
+        Return a list of all installed models.
+
+        By default, the following models aren't included:
+
+        - auto-created models for many-to-many relations without
+          an explicit intermediate table,
+        - models that have been swapped out.
+
+        Set the corresponding keyword argument to True to include such models.
+        """
+        self.check_models_ready()
+
+        result = []
+        for app_config in self.app_configs.values():
+            result.extend(app_config.get_models(include_auto_created, include_swapped))
+        return result
+
+    def get_model(self, app_label, model_name=None, require_ready=True):
+        """
+        Return the model matching the given app_label and model_name.
+
+        As a shortcut, app_label may be in the form <app_label>.<model_name>.
+
+        model_name is case-insensitive.
+
+        Raise LookupError if no application exists with this label, or no
+        model exists with this name in the application. Raise ValueError if
+        called with a single argument that doesn't contain exactly one dot.
+        """
+        if require_ready:
+            self.check_models_ready()
+        else:
+            self.check_apps_ready()
+
+        if model_name is None:
+            app_label, model_name = app_label.split(".")
+
+        app_config = self.get_app_config(app_label)
+
+        if not require_ready and app_config.models is None:
+            app_config.import_models()
+
+        return app_config.get_model(model_name, require_ready=require_ready)
+
+    def register_model(self, app_label, model):
+        # Since this method is called when models are imported, it cannot
+        # perform imports because of the risk of import loops. It mustn't
+        # call get_app_config().
+        model_name = model._meta.model_name
+        app_models = self.all_models[app_label]
+        if model_name in app_models:
+            if (
+                model.__name__ == app_models[model_name].__name__
+                and model.__module__ == app_models[model_name].__module__
+            ):
+                warnings.warn(
+                    "Model '%s.%s' was already registered. Reloading models is not "
+                    "advised as it can lead to inconsistencies, most notably with "
+                    "related models." % (app_label, model_name),
+                    RuntimeWarning,
+                    stacklevel=2,
+                )
+            else:
+                raise RuntimeError(
+                    "Conflicting '%s' models in application '%s': %s and %s."
+                    % (model_name, app_label, app_models[model_name], model)
+                )
+        app_models[model_name] = model
+        self.do_pending_operations(model)
+        self.clear_cache()
+
+    def is_installed(self, app_name):
+        """
+        Check whether an application with this name exists in the registry.
+
+        app_name is the full name of the app e.g. 'django.contrib.admin'.
+        """
+        self.check_apps_ready()
+        return any(ac.name == app_name for ac in self.app_configs.values())
+
+    def get_containing_app_config(self, object_name):
+        """
+        Look for an app config containing a given object.
+
+        object_name is the dotted Python path to the object.
+
+        Return the app config for the inner application in case of nesting.
+        Return None if the object isn't in any registered app config.
+        """
+        self.check_apps_ready()
+        candidates = []
+        for app_config in self.app_configs.values():
+            if object_name.startswith(app_config.name):
+                subpath = object_name[len(app_config.name) :]
+                if subpath == "" or subpath[0] == ".":
+                    candidates.append(app_config)
+        if candidates:
+            return sorted(candidates, key=lambda ac: -len(ac.name))[0]
+
+    def get_registered_model(self, app_label, model_name):
+        """
+        Similar to get_model(), but doesn't require that an app exists with
+        the given app_label.
+
+        It's safe to call this method at import time, even while the registry
+        is being populated.
+        """
+        model = self.all_models[app_label].get(model_name.lower())
+        if model is None:
+            raise LookupError("Model '%s.%s' not registered." % (app_label, model_name))
+        return model
+
+    @functools.lru_cache(maxsize=None)
+    def get_swappable_settings_name(self, to_string):
+        """
+        For a given model string (e.g. "auth.User"), return the name of the
+        corresponding settings name if it refers to a swappable model. If the
+        referred model is not swappable, return None.
+
+        This method is decorated with lru_cache because it's performance
+        critical when it comes to migrations. Since the swappable settings don't
+        change after Django has loaded the settings, there is no reason to get
+        the respective settings attribute over and over again.
+        """
+        to_string = to_string.lower()
+        for model in self.get_models(include_swapped=True):
+            swapped = model._meta.swapped
+            # Is this model swapped out for the model given by to_string?
+            if swapped and swapped.lower() == to_string:
+                return model._meta.swappable
+            # Is this model swappable and the one given by to_string?
+            if model._meta.swappable and model._meta.label_lower == to_string:
+                return model._meta.swappable
+        return None
+
+    def set_available_apps(self, available):
+        """
+        Restrict the set of installed apps used by get_app_config[s].
+
+        available must be an iterable of application names.
+
+        set_available_apps() must be balanced with unset_available_apps().
+
+        Primarily used for performance optimization in TransactionTestCase.
+
+        This method is safe in the sense that it doesn't trigger any imports.
+        """
+        available = set(available)
+        installed = {app_config.name for app_config in self.get_app_configs()}
+        if not available.issubset(installed):
+            raise ValueError(
+                "Available apps isn't a subset of installed apps, extra apps: %s"
+                % ", ".join(available - installed)
+            )
+
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = {
+            label: app_config
+            for label, app_config in self.app_configs.items()
+            if app_config.name in available
+        }
+        self.clear_cache()
+
+    def unset_available_apps(self):
+        """Cancel a previous call to set_available_apps()."""
+        self.app_configs = self.stored_app_configs.pop()
+        self.clear_cache()
+
+    def set_installed_apps(self, installed):
+        """
+        Enable a different set of installed apps for get_app_config[s].
+
+        installed must be an iterable in the same format as INSTALLED_APPS.
+
+        set_installed_apps() must be balanced with unset_installed_apps(),
+        even if it exits with an exception.
+
+        Primarily used as a receiver of the setting_changed signal in tests.
+
+        This method may trigger new imports, which may add new models to the
+        registry of all imported models. They will stay in the registry even
+        after unset_installed_apps(). Since it isn't possible to replay
+        imports safely (e.g. that could lead to registering listeners twice),
+        models are registered when they're imported and never removed.
+        """
+        if not self.ready:
+            raise AppRegistryNotReady("App registry isn't ready yet.")
+        self.stored_app_configs.append(self.app_configs)
+        self.app_configs = {}
+        self.apps_ready = self.models_ready = self.loading = self.ready = False
+        self.clear_cache()
+        self.populate(installed)
+
+    def unset_installed_apps(self):
+        """Cancel a previous call to set_installed_apps()."""
+        self.app_configs = self.stored_app_configs.pop()
+        self.apps_ready = self.models_ready = self.ready = True
+        self.clear_cache()
+
+    def clear_cache(self):
+        """
+        Clear all internal caches, for methods that alter the app registry.
+
+        This is mostly used in tests.
+        """
+        # Call expire cache on each model. This will purge
+        # the relation tree and the fields cache.
+        self.get_models.cache_clear()
+        if self.ready:
+            # Circumvent self.get_models() to prevent that the cache is refilled.
+            # This particularly prevents that an empty value is cached while cloning.
+            for app_config in self.app_configs.values():
+                for model in app_config.get_models(include_auto_created=True):
+                    model._meta._expire_cache()
+
+    def lazy_model_operation(self, function, *model_keys):
+        """
+        Take a function and a number of ("app_label", "modelname") tuples, and
+        when all the corresponding models have been imported and registered,
+        call the function with the model classes as its arguments.
+
+        The function passed to this method must accept exactly n models as
+        arguments, where n=len(model_keys).
+        """
+        # Base case: no arguments, just execute the function.
+        if not model_keys:
+            function()
+        # Recursive case: take the head of model_keys, wait for the
+        # corresponding model class to be imported and registered, then apply
+        # that argument to the supplied function. Pass the resulting partial
+        # to lazy_model_operation() along with the remaining model args and
+        # repeat until all models are loaded and all arguments are applied.
+        else:
+            next_model, *more_models = model_keys
+
+            # This will be executed after the class corresponding to next_model
+            # has been imported and registered. The `func` attribute provides
+            # duck-type compatibility with partials.
+            def apply_next_model(model):
+                next_function = partial(apply_next_model.func, model)
+                self.lazy_model_operation(next_function, *more_models)
+
+            apply_next_model.func = function
+
+            # If the model has already been imported and registered, partially
+            # apply it to the function now. If not, add it to the list of
+            # pending operations for the model, where it will be executed with
+            # the model class as its sole argument once the model is ready.
+            try:
+                model_class = self.get_registered_model(*next_model)
+            except LookupError:
+                self._pending_operations[next_model].append(apply_next_model)
+            else:
+                apply_next_model(model_class)
+
+    def do_pending_operations(self, model):
+        """
+        Take a newly-prepared model and pass it to each function waiting for
+        it. This is called at the very end of Apps.register_model().
+        """
+        key = model._meta.app_label, model._meta.model_name
+        for function in self._pending_operations.pop(key, []):
+            function(model)
+
+
+apps = Apps(installed_apps=None)

danix/templates.py

@@ -4,7 +4,7 @@ from danixfs import Danix
 from utils import check_equal_sentence
 class Essentials():
 
-    packages = ["build-base", "vim", "nano", "micro", "git"]
+    packages = ["build-base", "vim","emacs","nano", "micro", "git"]
        
 
 class Template():
@@ -92,6 +92,14 @@ class Template():
         return Template.essentials_menu() + Template.languange_menu(packages)
 
 class Languanges():
+
+    class VLang():
+        packages = ["v"]
+        config_commands = []
+
+        def install(self, environment_name, template):
+            Template.install(self.packages, environment_name, self.config_commands, template)
+
     class Python():
 
         packages = ["python3 py3-pip", "python3"]
@@ -127,7 +135,7 @@ class Languanges():
 
     class Lua():
         
-        packages = ["lua5.3", "lua5.2"]
+        packages = ["lua5.4", "lua5.3", "lua5.2"]
         config_commands = []
 
         def install(self, environment_name, template):
@@ -144,6 +152,19 @@ class Languanges():
             Template.install(self.packages, environment_name, self.config_commands, template)
 
 
+    class Dotnet():
+
+        package = ["dotnet7-sdk", "dotnet6-sdk"]
+        config_commands = [
+                            "apk add bash icu-libs krb5-libs libgcc libintl libssl1.1 libstdc++ zlib",
+                            "export HOME=/home/"
+                            "export USERPROFILE=root",
+                           ]
+
+        def install(self, environment_name, template):
+
+            Template.install(self.package, environment_name,self.config_commands, template)    
+
     class Go():
 
         packages = ["go", "musl-dev go"]
@@ -160,4 +181,4 @@ class Languanges():
 
         def install(self, environment_name, template):
             Template.install(self.packages, environment_name, self.config_commands, template)
-        
+        

danix/utils.py

@@ -1,5 +1,33 @@
 import os
-from settings import MAIN_REPO, MAIN_DIR, BASE_DIR
+import sh
+from settings import MAIN_REPO, MAIN_DIR, BASE_DIR, REPO_NAME
+
+
+def download_checksum():
+
+    return os.system(f"curl --silent -LO --output-dir /tmp/ {REPO_NAME}danixfs.checksum")
+
+
+def generate_checksum(package_path):
+    os.system("touch /tmp/local_danixfs.checksum")
+    return os.system(f"sha256sum {package_path} >> /tmp/local_danixfs.checksum")
+
+
+def remove_checksum_files():
+    os.system("rm /tmp/danixfs.checksum >/dev/null 2>&1")
+    os.system("rm /tmp/local_danixfs.checksum >/dev/null 2>&1")
+
+def read_line(file_path):
+    file = open(file_path, 'r')
+    checksum = file.readlines()
+    return checksum
+ 
+def validate_checksum(filesystem):
+
+    remote_checksum = ''.join(read_line(f"/tmp/danixfs.checksum")).replace(f"/tmp/{filesystem}/", "")
+    local_checksum  = ''.join(read_line(f"/tmp/local_danixfs.checksum")).replace(f"/tmp/{filesystem}/", "")
+
+    return True if local_checksum == remote_checksum else False
 
 def separate(path):
     list_path = path.split(" ")
@@ -91,6 +119,7 @@ def print_environment_list_header():
 
 @staticmethod
 def check_equal_sentence(left_expression, right_expression):
+
     return left_expression == right_expression
 
 @staticmethod