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 
-$ sudo make config
+```shell
+$ 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,75 +1,113 @@
-import uuid, os, settings, app
+import os, settings, app
 from sh import du
 from settings import MAIN_REPO
-from time import sleep
-
+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
+    def copy(environent_is_first, filesystem_name, environment_dir, host_directory):
+        
+        if environent_is_first:
+            return os.system(f"cp -r {MAIN_REPO}{filesystem_name}/danixfs{environment_dir} {host_directory} >/dev/null 2>&1")
+        else:
+            return os.system(f"cp -r {host_directory} {MAIN_REPO}{filesystem_name}/danixfs{environment_dir} >/dev/null 2>&1")
+
     @staticmethod
     def remove_snapshot(snapshot_name):
         return os.system(f"rm -r {MAIN_REPO}.snapshots/{snapshot_name} >/dev/null 2>&1")
 
     @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:
-            return "000M"
+        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"chroot {MAIN_REPO}{filesystem_uuid}/danixfs sh {MAIN_REPO}init.d/init.sh")
+        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")
 
     @staticmethod
-    def build_environment(packages, filesystem_uuid):
+    def build_environment(packages, config_comands, filesystem_uuid):
         filesystem = filesystem_uuid
 
         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}")
-
-
-        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!")
-        print("0 erros reported!")
+        resp_downloaded_checksum = download_checksum() 
+        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

@@ -5,7 +5,7 @@ import settings
 from danixfs import Danix
 from datetime import datetime
 from settings import SNAPSHOT_LIMIT
-from utils import print_snapshot_list_header, print_footer, print_environment_list_header, is_unique_database_tuple, get_message, check_equal_sentence, check_not_equal_sentence
+from utils import separate, get_size_in_mb_or_gb, print_snapshot_list_header, print_footer, print_environment_list_header, is_unique_database_tuple, get_message, check_equal_sentence, check_not_equal_sentence
 from django.core.exceptions import ValidationError
 
 def get_queryset_filtered(model, sub_attribute):
@@ -22,6 +22,34 @@ class Environment(models.Model):
     created         = models.DateField(default=datetime.now())
     template        = models.TextField(default="")
     
+
+    @staticmethod
+    def copy(path):
+
+        environent_is_first , environment_uuid, environment_dir, host_directory = separate(path)
+
+        if environment_uuid and environment_dir and host_directory:
+            
+            environment = get_queryset_filtered(Environment, environment_uuid)
+            filesystem_name = environment.first().filesystem_name
+
+            resp = Danix.copy(
+                                environent_is_first, 
+                                filesystem_name, 
+                                environment_dir, 
+                                host_directory
+                            )
+
+            if check_equal_sentence(resp, 0):
+                get_message("🟢 Elements copied successfuly!", True, 0)        
+            else:
+                get_message("🔴 Copy error!", True, 1)
+        else:
+            if environent_is_first:
+                get_message(f"🔴 Syntax error or element exist in {host_directory}!", True, 1)
+            else:
+                get_message(f"🔴 Syntax error or path not exist in subsystem!", True, 1)
+    
     @staticmethod
     def navigate(filesystem_name):
 
@@ -42,7 +70,7 @@ class Environment(models.Model):
                 if not check_not_equal_sentence(resp, 0):
                     
                     get_message(
-                                    message=settings.ENV_GENERIC_ERROR, 
+                                    message=f"🔴 {settings.ENV_GENERIC_ERROR}", 
                                     is_finishprogram=True, 
                                     finish_status_code=1
                                 )
@@ -50,21 +78,21 @@ class Environment(models.Model):
             elif expression ^ (not environment_first.status):
 
                 get_message(
-                                message=settings.ENV_STOPPED_ERROR,
+                                message=f"🔴 {settings.ENV_STOPPED_ERROR}",
                                 is_finishprogram=True, 
                                 finish_status_code=1
                             )   
 
             else:
                 get_message(
-                                message=settings.ENV_PATTERN_ERROR, 
+                                message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                                 is_finishprogram=True, 
                                 finish_status_code=1
                             )  
                 
         except ValidationError:
             get_message(
-                            message=settings.ENV_PATTERN_ERROR, 
+                            message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         )  
@@ -84,7 +112,7 @@ class Environment(models.Model):
                 if check_equal_sentence(environment_count, 0):
 
                     get_message(
-                                    message=settings.ENV_NOT_FOUND, 
+                                    message=f"🔴 {settings.ENV_NOT_FOUND}", 
                                     is_finishprogram=True, 
                                     finish_status_code=1
                                 )  
@@ -93,21 +121,21 @@ class Environment(models.Model):
                 environment.delete()
 
                 get_message(
-                                message=f"{settings.ENV_REMOVED} - {environment.filesystem_name}", 
+                                message=f"🟢 {settings.ENV_REMOVED} - {environment.filesystem_name}", 
                                 is_finishprogram=False, 
                                 finish_status_code=-1
                             ) 
             else:
 
                 get_message(
-                            message=settings.ENV_PATTERN_ERROR, 
+                            message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         )  
                 
         except Exception:
             get_message(
-                            message=settings.ENV_NOT_FOUND, 
+                            message=f"🔴 {settings.ENV_NOT_FOUND}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         ) 
@@ -126,7 +154,7 @@ class Environment(models.Model):
             if check_equal_sentence(environment_counter, 0):
 
                 get_message(
-                                message=settings.ENV_NOT_FOUND, 
+                                message=f"🔴 {settings.ENV_NOT_FOUND}", 
                                 is_finishprogram=True, 
                                 finish_status_code=1
                             ) 
@@ -135,13 +163,13 @@ class Environment(models.Model):
             environment.save()
 
             get_message(
-                            message=settings.ENV_STARTED, 
+                            message=f"🟢 {settings.ENV_STARTED}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         ) 
         else:
             get_message(
-                            message=settings.ENV_PATTERN_ERROR, 
+                            message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         )  
@@ -164,16 +192,16 @@ class Environment(models.Model):
 
             if check_equal_sentence(environment_counter, 0):
 
-                 get_message(message=settings.ENV_NOT_FOUND, is_finishprogram=True, finish_status_code=1) 
+                 get_message(message=f"🔴 {settings.ENV_NOT_FOUND}", is_finishprogram=True, finish_status_code=1) 
 
             environment.status = False
             environment.save()
 
-            get_message(message=settings.ENV_STOPPED, is_finishprogram=True, finish_status_code=1) 
+            get_message(message=f"🟢 {settings.ENV_STOPPED}", is_finishprogram=True, finish_status_code=1) 
 
         else:
             get_message(
-                            message=settings.ENV_PATTERN_ERROR, 
+                            message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         )  
@@ -197,12 +225,9 @@ class Environment(models.Model):
 
                 size_str = str(Danix.get_size(environment.filesystem_name, None))
 
-                size = int(size_str.replace("M",""))
-
-                if size >= 1000:
-                    size_str = f"{round(size/1000, 1)}G"
+                size_str = get_size_in_mb_or_gb(size_str)
                 
-                print(f"|  {name[0:11]}{(11-len(name)) * '.'}           {template}{(6-len(template)) * ' '}          {environment.created}         {environment.filesystem_name}        Alpine        {status_icon}      {size_str}B    |")
+                print(f"|  {name[0:11]}{(11-len(name)) * '.'}           {template}{(6-len(template)) * ' '}          {environment.created}         {environment.filesystem_name}        Alpine        {status_icon}      {size_str}    |")
 
         print_footer()
 
@@ -235,22 +260,27 @@ 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) 
+                        get_message(message="🔴 Error: Snapshot can not remove", is_finishprogram=True, finish_status_code=1) 
                 else:
-                    get_message(message="Snapshot does not exist!", is_finishprogram=True, finish_status_code=1) 
+                    get_message(message="🔴 Snapshot does not exist!", is_finishprogram=True, finish_status_code=1) 
             
             else:
                 get_message(
-                            message=settings.ENV_PATTERN_ERROR, 
+                            message=f"🔴 {settings.ENV_PATTERN_ERROR}", 
                             is_finishprogram=True, 
                             finish_status_code=1
                         ) 
                  
         except ValidationError:
-            get_message(message="Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
+            get_message(message="🔴 Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
 
     @staticmethod
     def back_snapshot(snapshot_name):
@@ -268,17 +298,16 @@ 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: 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)
 
-                get_message(message="Error: Environment was removed!", is_finishprogram=True, finish_status_code=1)
-
-            get_message(message="Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
+            get_message(message="🔴 Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
 
         except ValidationError:
             
-            get_message(message="Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
+            get_message(message="🔴 Snapshot does not exist!", is_finishprogram=True, finish_status_code=1)
 
     @staticmethod
     def create(subsystem_name):
@@ -295,7 +324,7 @@ class Snapshot(models.Model):
                 snapshots      = Snapshot.objects.filter(environment_id=environment_id)
 
                 if snapshots.count() >= int(SNAPSHOT_LIMIT):
-                    get_message(message="Snapshot limit exceeded! Please remove 1 snapshot to continue!", is_finishprogram=True, finish_status_code=1)
+                    get_message(message="🟠 Snapshot limit exceeded! Please remove 1 snapshot to continue!", is_finishprogram=True, finish_status_code=1)
                 else:
 
                     for snapshot in snapshots:
@@ -314,7 +343,7 @@ class Snapshot(models.Model):
                     resp = Danix.make_snapshot(environment.filesystem_name, snapshot_name)
 
                     if check_equal_sentence(resp, 0):
-                        print("Snapshot created successfully")
+                        print("🟢 Snapshot created successfully")
                         print(f"Snapshot name {snapshot_name}\n")
                         print(f"======================================")
                         print(f"Environment size: {Danix.get_size(environment.filesystem_name, None)}B")
@@ -324,7 +353,7 @@ class Snapshot(models.Model):
                     else:
 
                         Snapshot.objects.get(snapshot_name=snapshot_name,environment_id=environment).delete()
-                        print("Snapshot create error!")
+                        print("🔴 Snapshot create error!")
                         exit(1)
             else:
 
@@ -335,7 +364,7 @@ class Snapshot(models.Model):
                         )  
                 
         except Exception:
-           get_message(message="Snapshot create error: Environment does not exist!", is_finishprogram=True, finish_status_code=1)
+           get_message(message="🔴 Snapshot create error: Environment does not exist!", is_finishprogram=True, finish_status_code=1)
 
     @staticmethod
     def list_snapshots():
@@ -355,18 +384,14 @@ class Snapshot(models.Model):
                     environment_name = Environment.objects.filter(id=snapshot.environment_id.id).first().filesystem_name
                     size_str = str(Danix.get_size(environment_name, name))
                     
-                    size = int(size_str.replace("M",""))
-
-                    if size >= 1000:
-                        size_str = f"{round(size/1000, 1)}G"
-                    
-
+                    size_str = get_size_in_mb_or_gb(size_str)
+              
                 else:
 
                     environment_name = f'Environment Removed 🔴{14*" "}'
-                    size = "---"
+                    size_str = "-----"
                 
-                print(f"| {name}     {environment_name}         {snapshot.created}              {lastsnapshot_icon}              {size_str}B      |")
+                print(f"| {name}     {environment_name}         {snapshot.created}              {lastsnapshot_icon}              {size_str}      |")
        
         print_footer()
 

danix/main.py

@@ -1,7 +1,7 @@
 #!./venv/bin/python
 import argparse, os
 import app
-from utils import is_root
+from utils import is_root, check_system_configuration
 from templates import Languanges
 
 from db.models import Environment, Snapshot
@@ -14,19 +14,20 @@ parser = argparse.ArgumentParser(prog="Danix", add_help=True)
 
 usages = parser.add_argument_group("usages")
 
-usages.add_argument("-l", "--list",          action="store_true" , help="List all environments avaliable", required=False)
-usages.add_argument("-sl", "--snapshotlist", action="store_true",  help="List all subsystems snapshots",   required=False)
+usages.add_argument("-l" , "--list"        ,  action="store_true" ,  help="List all environments avaliable", required=False)
+usages.add_argument("-sl", "--snapshotlist",  action="store_true" ,  help="List all subsystems snapshots",   required=False)
 
-usages.add_argument("-S", "--start",                help="Start system environment",        required=False)
-usages.add_argument("-s", "--stop",                 help="Stop system environment",         required=False)
-usages.add_argument("-r", "--rm",                   help="Remove system environment",       required=False)
+usages.add_argument("-S", "--start"   ,             help="Start system environment",        required=False)
+usages.add_argument("-s", "--stop"    ,             help="Stop system environment",         required=False)
+usages.add_argument("-r", "--rm"      ,             help="Remove system environment",       required=False)
 usages.add_argument("-n", "--navigate",             help="Navigate inside the environment", required=False)
 
 usages.add_argument("-sr", "--snapshotremove",      help="Remove snapshot", required=False)
 usages.add_argument("-sc", "--snapshotcreate",      help="Create snapshot", required=False)
-usages.add_argument("-sb", "--snapshotback",        help="Back snapshot",   required=False)
+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"], required=False)
+usages.add_argument("-o", "--option",   choices=["clike", "java", "python", "ruby", "lua", "go", "ada", "dotnet", "v"], required=False)
 
 args = parser.parse_args()
 
@@ -34,64 +35,76 @@ languanges_and_softwares = {
                                 "clike"  : Languanges.CLike(),
                                 "java"   : Languanges.Java(),
                                 "python" : Languanges.Python(),
-                                #"ruby"   : Languanges.Ruby()
+                                "ruby"   : Languanges.Ruby(),
+                                "lua"    : Languanges.Lua(),
+                                "go"     : Languanges.Go(),
+                                "ada"    : Languanges.Ada(),
+                                "dotnet" : Languanges.Dotnet(),
+                                "v"      : Languanges.VLang()
                             }
 
-if args.option:
+if check_system_configuration():
+    if args.option:
 
-    name = input("Please enter environment name: ")
-    languanges_and_softwares.get(args.option).install(name, args.option)
+        name = input("Please enter environment name: ")
+        languanges_and_softwares.get(args.option).install(name, args.option)
 
-if args.navigate:
-    Environment.navigate(args.navigate)
+    if args.navigate:
+        Environment.navigate(args.navigate)
 
-if args.start:
-    Environment.start_environment(args.start)
+    if args.start:
+        Environment.start_environment(args.start)
 
-if args.rm:
-     user_confirm = input("Type 'y' to continue: ")
-     
-     if user_confirm == 'y':
-        environments = str(args.rm).split(" ")
-    
-        for environment in environments:
-            Environment.rm_environment(environment)
-        
-        exit(0)
-     print("[Danix]: System abort!")
+    if args.rm:
+         user_confirm = input("Type 'y' to continue: ")
 
-if args.stop:
-    Environment.stop_environment(args.stop)
+         if user_confirm == 'y':
+            environments = str(args.rm).split(" ")
 
-if args.snapshotcreate:
-    user_confirm = input("Type 'y' to continue: ")
+            for environment in environments:
+                Environment.rm_environment(environment)
 
-    if user_confirm == 'y':
-        Snapshot.create(args.snapshotcreate)
-    print("[Danix]: System abort!")
-    
-if args.list:
-    Environment.list_environments()
+            exit(0)
+         print("🔴 [Danix]: System abort!")
 
-if args.snapshotlist:
-    Snapshot.list_snapshots()
+    if args.stop:
+        Environment.stop_environment(args.stop)
 
-if args.snapshotback:
-    user_confirm = input("Type 'y' to continue: ")
+    if args.snapshotcreate:
+        user_confirm = input("Type 'y' to continue: ")
 
-    if user_confirm == 'y':
-        Snapshot.back_snapshot(args.snapshotback)
-    print("[Danix]: System abort!")
+        if user_confirm == 'y':
+            Snapshot.create(args.snapshotcreate)
+        print("🔴 [Danix]: System abort!")
 
-if args.snapshotremove:
-    user_confirm = input("Type y to continue: ")
-    
-    if user_confirm == 'y':
+    if args.list:
+        Environment.list_environments()
 
-        snapshots = str(args.snapshotremove).split(" ")
-    
-        for snapshot in snapshots:
-            Snapshot.rm_snapshot(snapshot)
-        exit(0)
+    if args.snapshotlist:
+        Snapshot.list_snapshots()
 
-    print("[Danix]: System abort!")
+    if args.snapshotback:
+        user_confirm = input("Type 'y' to continue: ")
+
+        if user_confirm == 'y':
+            Snapshot.back_snapshot(args.snapshotback)
+        print("🔴 [Danix]: System abort!")
+
+    if args.snapshotremove:
+        user_confirm = input("Type y to continue: ")
+
+        if user_confirm == 'y':
+
+            snapshots = str(args.snapshotremove).split(" ")
+
+            for snapshot in snapshots:
+                Snapshot.rm_snapshot(snapshot)
+            exit(0)
+
+        print("🔴 [Danix]: System abort!")
+
+    if args.copy:
+        Environment.copy(args.copy)
+else:
+    print("🔴 Danix system is not configured!")
+    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 $(DANIX_PATH)/.env
-	@echo Danix cleaned!
+	@rm -r $(DANIX_PATH) > /dev/null 2>&1
+	@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/settings.py

@@ -19,6 +19,7 @@ BASE_DIR = Path(__file__).resolve().parent.parent
 env = environ.Env()
 
 MAIN_DIR = f"{BASE_DIR}/danix"
+
 environ.Env.read_env(os.path.join(MAIN_DIR, '.env'))
 
 # Quick-start development settings - unsuitable for production

danix/templates.py

@@ -4,13 +4,13 @@ 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():
 
     @staticmethod
-    def install(packages, environment_name, template):
+    def install(packages, environment_name, config_commands, template):
 
         filesystem_name = uuid.uuid4()
 
@@ -28,8 +28,7 @@ class Template():
             joined_packages = Template.menu(packages)
 
             Environment.set_active(filesystem_name)
-            Danix.build_environment(joined_packages, filesystem_name)
-
+            Danix.build_environment(joined_packages, config_commands, filesystem_name)
 
 
     @staticmethod
@@ -42,12 +41,20 @@ class Template():
 
         print('Select essentials packages:')
         print(f'Example: 1 2 to install {packages[0]}, {packages[1]}')
+        
         packages_selected = input()
 
         list_selected_packages = []
 
-        for pos in packages_selected.split(" "):
-            list_selected_packages.append(packages[int(pos)-1])
+        try:
+
+            for pos in packages_selected.split(" "):
+                list_selected_packages.append(packages[int(pos)-1])
+
+        except Exception:
+            
+            print("🔴 Invalid option: Please select a valid menu option!\n")
+            Template.languange_menu(packages)
 
         return list_selected_packages
 
@@ -69,8 +76,14 @@ class Template():
 
         list_essentials_packages = []
 
-        for pos in essentials_packages_selected.split(" "):
-            list_essentials_packages.append(essentials_packages[int(pos)-1])
+        try:
+
+            for pos in essentials_packages_selected.split(" "):
+                list_essentials_packages.append(essentials_packages[int(pos)-1])
+
+        except Exception:
+            print("🔴 Invalid option: Please select a valid menu option!\n")
+            Template.essentials_menu()
 
         return list_essentials_packages
                 
@@ -79,24 +92,93 @@ 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"]
+        packages = ["python3 py3-pip", "python3"]
+        config_commands = []
 
         def install(self, environment_name, template):
 
-            Template.install(self.packages, environment_name, template)
+            Template.install(self.packages, environment_name, self.config_commands, template)
             
     class CLike():
 
         packages = ["gcc", "g++", "clang", "rust cargo"]
+        config_commands = []
 
         def install(self, environment_name, template):
-            Template.install(self.packages, environment_name, template)
+            Template.install(self.packages, environment_name, self.config_commands, template)
 
     class Java():
 
         packages = ["openjdk8", "openjdk11", "openjdk17"]
+        config_commands = []
 
         def install(self, environment_name, template):
-            Template.install(self.packages, environment_name, template)
+            Template.install(self.packages, environment_name, self.config_commands,template)
+
+    class Ruby():
+        packages = ["ruby", "ruby-full"]
+        config_commands = []
+
+        def install(self, environment_name, template):
+            Template.install(self.packages, environment_name, self.config_commands, template)
+
+
+    class Lua():
+        
+        packages = ["lua5.4", "lua5.3", "lua5.2"]
+        config_commands = []
+
+        def install(self, environment_name, template):
+
+            Template.install(self.packages, environment_name, self.config_commands, template)
+
+    class Ada():
+
+        packages = ["gcc gcc-gnat", "gcc", "gcc-gnat"]
+        config_commands = []
+
+        def install(self, environment_name, template):
+
+            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"]
+        config_commands = []
+
+        config_commands = [
+            "export GOPATH=/root/go >/dev/null 2>&1",
+            "export PATH=${GOPATH}/bin:/usr/local/go/bin:$PATH >/dev/null 2>&1",
+            "export GOBIN=$GOROOT/bin >/dev/null 2>&1",
+            "mkdir -p ${GOPATH}/src ${GOPATH}/bin >/dev/null 2>&1",
+            "export GO111MODULE=on >/dev/null 2>&1",
+            "export GOCACHE=/root/go/cache >/dev/null 2>&1"
+        ]
+
+        def install(self, environment_name, template):
+            Template.install(self.packages, environment_name, self.config_commands, template)
+        

danix/utils.py

@@ -1,9 +1,109 @@
 import os
+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(" ")
+
+    environment_path = None
+    environment_uuid = None
+    host_path        = None
+    environent_is_first = False
+
+    if len(list_path) >= 2:
+
+        if list_path[1]:
+            if str(list_path[1]).__contains__(":"):
+
+                environment_uuid = list_path[1].split(":")[0]
+                environment_path = list_path[1].split(":")[1]
+
+            else:
+                host_path = list_path[1]
+
+        if list_path[0]:
+
+            if str(list_path[0]).__contains__(":"):
+
+                environent_is_first = True
+                environment_uuid = list_path[0].split(":")[0]
+                environment_path = list_path[0].split(":")[1]
+
+            else:
+                host_path = list_path[0]
+                
+    return environent_is_first, environment_uuid, environment_path, host_path
+
+def check_create_dir():
+    mainrepo_resp = os.system(f"cd {MAIN_REPO} >/dev/null 2>&1")
+    snapshot_resp = os.system(f" cd {MAIN_REPO}.snapshots >/dev/null 2>&1")
+
+    return True if mainrepo_resp == 0 and snapshot_resp == 0 else False
+
+def check_create_db():
+    return True if os.system(f"cat {MAIN_DIR}/db/db.sqlite3 >/dev/null 2>&1") == 0 else False
+
+def check_create_dotenv():
+    return True if os.system(f"cat {BASE_DIR}/danix/.env >/dev/null 2>&1") == 0 else False
+
+@staticmethod
+def check_system_configuration():
+
+    check_dir_resp = check_create_dir()
+    check_db_resp  = check_create_db()
+    check_env_resp = check_create_dotenv()
+
+    return check_dir_resp and check_db_resp and check_env_resp
 
 @staticmethod
 def print_footer():
     print("================================================================================================================================================")
 
+@staticmethod
+def get_size_in_mb_or_gb(size_str):
+
+    try:
+
+        size = int(size_str.replace("M","").replace(",","."))
+    
+        if size >= 1000:
+
+            return f"{round(size/1000, 1)}GB"
+        elif size <= 100:
+
+            return size_str + "B "
+
+    except Exception:
+        return size_str.replace(",",".") + "B"
+       
+    return size_str + "B"
 
 @staticmethod
 def print_snapshot_list_header():
@@ -19,6 +119,7 @@ def print_environment_list_header():
 
 @staticmethod
 def check_equal_sentence(left_expression, right_expression):
+
     return left_expression == right_expression
 
 @staticmethod