simo 2.3.2__py3-none-any.whl → 2.3.4__py3-none-any.whl

simo/backups/admin.py

@@ -0,0 +1,19 @@
+from django.contrib import admin
+from .models import Backup
+
+
+@admin.register(Backup)
+class BackupAdmin(admin.ModelAdmin):
+    list_display = 'datetime', 'device', 'filepath'
+    fields = 'datetime', 'device', 'filepath'
+    readonly_fields = 'datetime', 'device', 'filepath'
+    list_filter = 'datetime', 'mac',
+
+    def has_change_permission(self, request, obj=None):
+        return False
+
+    def has_add_permission(self, request):
+        return False
+
+    def has_delete_permission(self, request, obj=None):
+        return False

simo/backups/dynamic_settings.py

@@ -0,0 +1,21 @@
+from dynamic_preferences.preferences import Section
+from dynamic_preferences.types import (
+    BooleanPreference, StringPreference, ChoicePreference, IntegerPreference,
+)
+from dynamic_preferences.registries import global_preferences_registry
+
+backups = Section('backups')
+
+
+@global_preferences_registry.register
+class LastBackupError(StringPreference):
+    section = backups
+    name = 'last_error'
+    default = ''
+
+
+@global_preferences_registry.register
+class LastBackupCheck(IntegerPreference):
+    section = backups
+    name = 'last_check'
+    default = 0

simo/backups/migrations/0001_initial.py

@@ -0,0 +1,27 @@
+# Generated by Django 4.2.10 on 2024-10-01 13:01
+
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Backup',
+            fields=[
+                ('id', models.AutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('datetime', models.DateTimeField(db_index=True)),
+                ('mac', models.CharField(db_index=True, max_length=100)),
+                ('filepath', models.CharField(max_length=200)),
+            ],
+            options={
+                'ordering': ('datetime',),
+                'unique_together': {('datetime', 'mac')},
+            },
+        ),
+    ]

simo/backups/models.py

@@ -0,0 +1,18 @@
+import uuid
+from django.db import models
+
+
+class Backup(models.Model):
+    datetime = models.DateTimeField(db_index=True)
+    mac = models.CharField(max_length=100, db_index=True)
+    filepath = models.CharField(max_length=200)
+
+    class Meta:
+        unique_together = 'datetime', 'mac'
+        ordering = 'datetime',
+
+    @property
+    def device(self):
+        if self.mac == str(hex(uuid.getnode())):
+            return "This machine"
+        return self.mac

simo/backups/tasks.py

@@ -0,0 +1,272 @@
+import os, subprocess, json, uuid, datetime, shutil
+from datetime import datetime, timezone
+from celeryc import celery_app
+from simo.conf import dynamic_settings
+
+
+@celery_app.task
+def check_backups():
+    '''
+    syncs up backups on external medium to the database
+    '''
+    from .models import Backup
+
+    try:
+        lv_group, lv_name, mountpoint = get_partitions()
+    except:
+        return Backup.objects.all().delete()
+
+
+    backups_dir = os.path.join(mountpoint, 'simo_backups')
+    if not os.path.exists(backups_dir):
+        return Backup.objects.all().delete()
+
+    backups_mentioned = []
+    for item in os.listdir(backups_dir):
+        if not item.startswith('hub-'):
+            continue
+        hub_mac = item.split('-')[1]
+        hub_dir = os.path.join(backups_dir, item)
+        for month_folder in os.listdir(hub_dir):
+            try:
+                year, month = month_folder.split('-')
+                year, month = int(year), int(month)
+            except:
+                continue
+            for filename in os.listdir(os.path.join(hub_dir, month_folder)):
+                try:
+                    day, time, back = filename.split('.')
+                    hour, minute, second = time.split('-')
+                    day, hour, minute, second = \
+                        int(day), int(hour), int(minute), int(second)
+                except:
+                    continue
+
+                obj, new = Backup.objects.update_or_create(
+                    datetime=datetime(
+                        year, month, day, hour, minute, second,
+                        tzinfo=timezone.utc
+                    ), mac=hub_mac, defaults={
+                        'filepath': os.path.join(
+                            hub_dir, month_folder, filename
+                        )
+                    }
+                )
+                backups_mentioned.append(obj.id)
+
+    Backup.objects.all().exclude(id__in=backups_mentioned).delete()
+
+    dynamic_settings['backups__last_check'] = datetime.now()
+
+
+def create_snap(lv_group, lv_name):
+    try:
+        return subprocess.check_output(
+            f'lvcreate -s -n {lv_name}-snap {lv_group}/{lv_name} -L 3G',
+            shell=True
+        ).decode()
+    except:
+        return ''
+
+
+def get_lvm_partition(lsblk_data):
+    for device in lsblk_data:
+        if device['type'] == 'lvm' and device['mountpoint'] == '/':
+            return device
+        if 'children' in device:
+            return get_lvm_partition(device['children'])
+
+
+def get_backup_device(lsblk_data):
+    for device in lsblk_data:
+        if not device['hotplug']:
+            continue
+        target_device = None
+        if device.get('fstype') == 'exfat':
+            target_device = device
+        elif device.get('children'):
+            for child in device.get('children'):
+                if child.get('fstype') == 'exfat':
+                    target_device = child
+        if target_device:
+            return target_device
+
+
+def get_partitions():
+
+    lsblk_data = json.loads(subprocess.check_output(
+        'lsblk --output NAME,HOTPLUG,MOUNTPOINT,FSTYPE,TYPE,LABEL,PARTLABEL  --json',
+        shell=True
+    ).decode())['blockdevices']
+
+    # Figure out if we are running in an LVM group
+
+    lvm_partition = get_lvm_partition(lsblk_data)
+    if not lvm_partition:
+        print("No LVM partition!")
+        dynamic_settings['backups__last_error'] = 'No LVM partition!'
+        return
+
+    try:
+        name = lvm_partition.get('name')
+        split_at = name.find('-')
+        lv_group = name[:split_at]
+        lv_name = name[split_at + 1:].replace('--', '-')
+    except:
+        print("Failed to identify LVM partition")
+        dynamic_settings['backups__last_error'] = \
+            'Failed to identify LVM partition'
+        return
+
+    if not lv_name:
+        print("LVM was not found on this system. Abort!")
+        dynamic_settings['backups__last_error'] = \
+            'Failed to identify LVM partition name'
+        return
+
+
+    # check if we have any removable devices storage devices plugged in
+
+    backup_device = get_backup_device(lsblk_data)
+
+    if not backup_device:
+        dynamic_settings['backups__last_error'] = \
+            'No external exFAT backup device on this machine'
+        return
+
+    if lvm_partition.get('partlabel'):
+        mountpoint = f"/media/{backup_device['partlabel']}"
+    elif lvm_partition.get('label'):
+        mountpoint = f"/media/{backup_device['label']}"
+    else:
+        mountpoint = f"/media/{backup_device['name']}"
+
+    if not os.path.exists(mountpoint):
+        os.makedirs(mountpoint)
+
+    if backup_device.get('mountpoint') != mountpoint:
+
+        if backup_device.get('mountpoint'):
+            subprocess.call(f"umount {backup_device['mountpoint']}", shell=True)
+
+        subprocess.call(
+            f'mount /dev/{backup_device["name"]} {mountpoint}', shell=True,
+            stdout=subprocess.PIPE
+        )
+
+    return lv_group, lv_name, mountpoint
+
+
+@celery_app.task
+def perform_backup():
+
+    try:
+        lv_group, lv_name, mountpoint = get_partitions()
+    except:
+        return
+
+    output = create_snap(lv_group, lv_name)
+    if not output:
+        subprocess.check_output(
+            f'lvremove -f {lv_group}/{lv_name}-snap',
+            shell=True
+        )
+        output = create_snap(lv_group, lv_name)
+
+    if f'Logical volume "{lv_name}-snap" created' not in output:
+        print(output)
+        print(f"Unable to create {lv_name}-snap.")
+        return
+
+    mac = str(hex(uuid.getnode()))
+    device_backups_path = f'{mountpoint}/simo_backups/hub-{mac}'
+    if not os.path.exists(device_backups_path):
+        os.makedirs(device_backups_path)
+
+    now = datetime.datetime.now()
+    level = now.day
+    month_folder = os.path.join(
+        device_backups_path, f'{now.year}-{now.month}'
+    )
+    if not os.path.exists(month_folder):
+        os.makedirs(month_folder)
+        level = 0
+
+    if level != 0:
+        # check if level 0 exists
+        level_0_exists = False
+        for filename in os.listdir(month_folder):
+            if '-' not in filename:
+                continue
+            try:
+                level, date = filename.split('-')
+                level = int(level)
+                if level == 0:
+                    level_0_exists = True
+                    break
+            except:
+                continue
+        if not level_0_exists:
+            print("Level 0 does not exist! Backups must be started from 0!")
+            shutil.rmtree(month_folder)
+            os.makedirs(month_folder)
+            level = 0
+
+    time_mark = now.strftime("%H-%M-%S")
+    backup_file = f"{month_folder}/{now.day}.{time_mark}.back"
+    snap_mapper = f"/dev/mapper/{lv_group}-{lv_name.replace('-', '--')}--snap"
+    label = f"simo {now.strftime('%Y-%m-%d')}"
+    dumpdates_file = os.path.join(month_folder, 'dumpdates')
+
+    estimated_size = int(subprocess.check_output(
+        f'dump -{level} -Squz9 -b 1024 {snap_mapper}',
+        shell=True
+    )) * 0.5
+
+    folders = []
+    for item in os.listdir(device_backups_path):
+        if not os.path.isdir(os.path.join(device_backups_path, item)):
+            continue
+        try:
+            year, month = item.split('-')
+            folders.append([
+                os.path.join(device_backups_path, item),
+                int(year) * 12 + int(month)
+            ])
+        except:
+            continue
+    folders.sort(key=lambda v: v[1])
+
+    # delete old backups to free up space required for this backup to take place
+    while shutil.disk_usage('/media/backup').free < estimated_size:
+        remove_folder = folders.pop()[0]
+        print(f"REMOVE: {remove_folder}")
+        shutil.rmtree(remove_folder)
+
+    success = False
+    try:
+        subprocess.check_call(
+            f'dump -{level} -quz9 -b 1024 -L "{label}" -D {dumpdates_file} -f {backup_file} {snap_mapper}',
+            shell=True,
+        )
+        success = True
+    except:
+        try:
+            os.remove(backup_file)
+            print("Dump failed!")
+        except:
+            pass
+
+    subprocess.call(
+        f"lvremove -f {lv_group}/{lv_name}-snap", shell=True,
+        stdout=subprocess.PIPE
+    )
+    if success:
+        print("DONE!")
+        dynamic_settings['backups__last_error'] = ''
+
+
+@celery_app.on_after_finalize.connect
+def setup_periodic_tasks(sender, **kwargs):
+    sender.add_periodic_task(60 * 60, check_backups.s())
+    sender.add_periodic_task(60 * 60 * 8, perform_backup.s()) # perform auto backup every 8 hours

simo/core/context.py

@@ -15,11 +15,11 @@ def additional_templates_context(request):
         'dynamic_settings': dynamic_settings,
         'current_version': pkg_resources.get_distribution('simo').version,
         'update_available': is_update_available(True),
-        'instances': Instance.objects.all(),
+        'instances': request.user.instances,
         'current_instance': get_current_instance()
     }
 
-    if request.path.endswith('/admin/'):
+    if request.path == '/admin/':
         ctx['todos'] = []
         for app_name, app in apps.app_configs.items():
             try:

simo/core/management/commands/on_http_start.py

@@ -74,11 +74,10 @@ def update_auto_update():
     cron.write()
 
 
-
-
 class Command(BaseCommand):
 
     def handle(self, *args, **options):
         prepare_mosquitto()
         from simo.core.tasks import maybe_update_to_latest
         maybe_update_to_latest.delay()
+        update_auto_update()

simo/core/management/update.py

@@ -8,23 +8,6 @@ import pkg_resources
 HUB_DIR = '/etc/SIMO/hub'
 
 
-def install_dependencies():
-
-    status = subprocess.call(
-        'apt install postgresql libpq-dev postgresql-client '
-        'postgresql-client-common python3-pip redis-server supervisor '
-        'mosquitto libopenjp2-7 libtiff5-dev pkg-config libcairo2-dev '
-        'libgirepository1.0-dev libcairo2 libudev-dev gdal-bin net-tools '
-        'nginx postgis openvpn ffmpeg libsm6 libxext6 ssh keychain -y',
-        shell=True
-    )
-    if status != 0:
-        print("Unable install required packages.")
-        return
-
-    return True
-
-
 def perform_update():
 
     proc = subprocess.Popen(
@@ -35,8 +18,6 @@ def perform_update():
     if proc.returncode:
         raise Exception(err.decode())
 
-    install_dependencies()
-
     proc = subprocess.Popen(
         [os.path.join(HUB_DIR, 'manage.py'), 'migrate'],
         cwd=HUB_DIR,

simo/core/middleware.py

@@ -2,6 +2,7 @@ import pytz
 import threading
 import re
 from django.utils import timezone
+from django.shortcuts import render
 
 
 _thread_locals = threading.local()
@@ -15,9 +16,13 @@ def get_current_request():
 
 
 def introduce_instance(instance, request=None):
+    if request.user.is_authenticated \
+    and instance not in request.user.instances:
+        return
     _thread_locals.instance = instance
     if request:
         request.session['instance_id'] = instance.id
+        request.instance = instance
 
 
 def get_current_instance(request=None):
@@ -51,6 +56,17 @@ def simo_router_middleware(get_response):
 def instance_middleware(get_response):
 
     def middleware(request):
+
+        if request.path.startswith('/admin'):
+            if not (request.user.is_authenticated and request.user.is_master):
+                return render(request, 'admin/msg_page.html', {
+                    'page_title': "You are not allowed in here",
+                    'msg': "Page you are trying to access is only for hub masters.",
+                    'suggestion': "Try switching your user to the one who has proper "
+                                  "rights to come here or ask for somebody who already has "
+                                  "master rights enable these rights for you."
+                })
+
         from simo.core.models import Instance
 
         instance = None

simo/core/serializers.py

@@ -416,11 +416,13 @@ class ComponentSerializer(FormSerializer):
             controller_uid=controller_uid, instance=instance,
             **kwargs
         )
+        # only masters and superusers can fully manage components via app
+        # others can only change basic fields
         if not self.context['request'].user.is_master:
             user_role = self.context['request'].user.get_role(
                 self.context['instance']
             )
-            if not user_role.is_superuser and user_role.is_owner:
+            if not user_role.is_superuser:
                 for field_name in list(form.fields.keys()):
                     if field_name not in form.basic_fields:
                         del form.fields[field_name]

simo/core/tasks.py

@@ -7,8 +7,6 @@ import requests
 import subprocess
 import threading
 import pkg_resources
-import sys
-import traceback
 import uuid
 from django.db.models import Q
 from django.db import connection, transaction

simo/fleet/controllers.py

@@ -424,12 +424,11 @@ class PWMOutput(FadeMixin, FleeDeviceMixin, BasicOutputMixin, BaseDimmer):
         return value
 
 
-
 class RGBLight(FleeDeviceMixin, BasicOutputMixin, BaseRGBWLight):
     config_form = ColonelRGBLightConfigForm
 
 
-class DualMotorValve(FleeDeviceMixin, BasicOutputMixin, BaseSwitch):
+class DualMotorValve(FleeDeviceMixin, BasicOutputMixin, BaseDimmer):
     gateway_class = FleetGatewayHandler
     config_form = DualMotorValveForm
     name = "Dual Motor Valve"

simo/fleet/forms.py

@@ -1109,6 +1109,12 @@ class BlindsConfigForm(ColonelComponentForm):
         help_text="Time in seconds it takes for your blinds to go "
                   "from fully closed to fully open."
     )
+    close_duration = forms.FloatField(
+        label='Close duration', min_value=1, max_value=360000,
+        initial=30,
+        help_text="Time in seconds it takes for your blinds to go "
+                  "from fully open to fully closed."
+    )
     control_type = forms.ChoiceField(
         initial=0, required=True, choices=(
             ('hold', "Hold"), ('click', 'Click')

simo/generic/forms.py

@@ -7,7 +7,7 @@ from django.contrib.contenttypes.models import ContentType
 from simo.core.forms import HiddenField, BaseComponentForm
 from simo.core.models import Icon, Component
 from simo.core.controllers import (
-    BEFORE_SET, BinarySensor, NumericSensor, MultiSensor, Switch
+    BEFORE_SET, BinarySensor, NumericSensor, MultiSensor, Switch, Dimmer
 )
 from simo.core.widgets import PythonCode, LogOutputWidget
 from dal import autocomplete, forward
@@ -615,7 +615,9 @@ class ContourForm(forms.Form):
 
     name = forms.CharField()
     switch = forms.ModelChoiceField(
-        Component.objects.filter(base_type=Switch.base_type),
+        Component.objects.filter(
+            base_type__in=(Switch.base_type, Dimmer.base_type)
+        ),
         widget=autocomplete.ModelSelect2(
             url='autocomplete-component', attrs={'data-html': True},
             forward=(

simo/settings.py

@@ -72,6 +72,7 @@ INSTALLED_APPS = [
     'simo.generic',
     'simo.multimedia',
     'simo.fleet',
+    'simo.backups',
 
     'django.contrib.admin',
     'adminsortable2',