#+title: Projekthandbuch :preamble: #+setupfile: ~/git_repos/notes/settings/html_theme/setup/theme-readtheorg.setup #+author: Andreas Zweili #+latex_class: article #+latex_class_options: [a4paper,11pt] #+latex_header: \input{general/style} #+latex_header: \loadglsentries[main]{general/glossary} #+otions: H:5 todo:t #+language: de #+startup: align #+exclude_tags: no_export :end: * Über dieses Dokument Im nachfolgenden Abschnitt finden Sie allgemeine Informationen zu diesem Dokument. ** Beschreibung Diese Arbeit hat zum Ziel, die Planung und Erstellung einer grafischen Oberfläche zum einfachen Bedienen der Software gls:borg footcite:borgbackup , durchzuführen sowie zu dokumentieren. ** Zweck und Inhalt Zweck dieses Dokumentes ist die vollständige und nachvollziehbare Dokumentation zur Diplomarbeit von Andreas Zweili. ** Aufbau Alle Inhalte sind chronologisch sortiert, vom ältesten zum jüngsten Ereignis, und nach Kapiteln getrennt. ** Lizenz Dieses Dokument wurde von Andreas Zweili im Rahmen der Diplomarbeit an der IBZ Schule erstellt und steht unter der gls:cc BY-SA 4.0 footcite:cc Lizenz. Dadurch darf die Arbeit unter Beibehalten der Lizenz kopiert und weiterverarbeitet werden. Zusätzlich muss der Urheber genannt werden. * Initialisierung ** Vision Die Software soll gls:borg für den durchschnittlichen Computer User zugänglich machen. Backups sollen dabei schnell und unkompliziert erstellt werden können. Auch die Möglichkeit automatischer im Hintergrund laufender Backups soll dem User gegeben sein, damit die Hürde für Backups so tief wie möglich gehalten wird. Die besten Backups sind solche bei denen man gar nicht mehr weiss das man sie hat bis man sie braucht. ** Ausgangslage gls:borg ist deshalb interessant, weil es während einem Backup relativ wenig Ressource im Vergleich zu anderen Systemen benötigt und schon relativ lange aktiv entwickelt wird. Dadurch ist es im Alltag geprüft worden. Des Weiteren bietet gls:borg die Funktion für Verschlüsselung was es einem User ermöglicht die Daten auf einem unsicheren Cloud Speicher abzulegen. Des Weiteren speichert gls:borg die Daten mit Block basierter gls:dedup ab. Dies hat den riesigen Vorteil das bei einem Backup nur die Änderungen auf Block-Ebene gespeichert werden und nicht jedes Mal die ganze Datei kopiert werden muss. Damit ermöglicht die Software auch Backups von sehr grossen Dateien, wie Videos oder Disk Images von virtuellen Maschinen, in mehreren Versionen. Ohne dabei jedoch signifikant mehr an Speicher zu benötigen. Zusätzlich werden die Backups dadurch rasend schnell ausgeführt. Gerade dieses Feature macht gls:borg in den Augen des Autors besonders interessant da sich der durchschnittliche User möglichst wenig mit Dingen wie Backups auseinandersetzen möchte. Umso besser also, wenn sie schnell gehen und so wenig Speicherplatz wie möglich verbrauchen. gls:borg wird jedoch komplett über die Kommandozeile bedient. Somit ist es für normale Benutzer eher schwierig den Zugang zu der Software zu finden geschweige denn sie zu bedienen. gls:borg bietet Entwicklern eine gls:json, gls:api, mit welcher sie, von gls:borg ausgegebenen Dateien einfach weiterverarbeiten können. gls:borg steht unter einer gls:bsd footcite:bsd Lizenz zur Verfügung und ist somit gls:libre. Das Projekt muss dabei vom Studenten in Eigenarbeit und einer Zeit von 250 Stunden bis zum 18. März 2019 erarbeitet werden. ** Projektziele Das Hauptziel der Arbeit soll es sein eine einfach nutzbare grafische Oberfläche für gls:borg zu entwickeln. Da gls:borg selber freie Software ist und der Autor mit gls:libre viel gute Erfahrungen gemacht hat, soll das Projekt selber auch wieder gls:libre sein. Zum einen um der Community etwas zurückzugeben des weiteren, um anderen Entwicklern die Möglichkeit zu geben die Software zu verbessern und weiter zu entwickeln. Als neben läufiges Ziel soll mit dieser Arbeit auch die Verbreitung von freier Software gefördert werden. Dies wird insbesondere dadurch erreicht, dass die Software selbst unter der gls:gpl Version 3 footcite:gplv3 veröffentlicht wird. Wenn möglich sollen während der Entwicklung auch hauptsächlich freie Software verwendet werden. Die gesamte Arbeit wird zudem zu jedem Zeitpunkt öffentlich einsehbar sein. Der Quelltext der Dokumentation ist unter diesem Link erreichbar: https://git.2li.ch/Nebucatnetzer/thesis Die Entwicklung wird hauptsächlich auf einem Linux System stattfinden. Da BorgBackup einerseits hauptsächlich auf Unix Systeme ausgelegt ist und anderseits die Hauptzielgruppe des Projektes auch auf Linux Usern liegt. Trotzdem sollen im Projekt cross-plattform fähige Technologien eingesetzt werden damit es in der Zukunft möglich ist das Projekt auf andere Plattformen auszuweiten. *** Ziele inklusive Gewichtung Im Projektantrag wurden vor gängig folgende Ziele definiert und entsprechend gewichtet. Die Gewichtung wurde dabei so vorgenommen, dass Ziele mit einer Muss-Gewichtung den Minimalanforderungen der Software entsprechen. Die weiteren Ziele wurden dann mit Ziffern von 5 bis 1 gewichtet. Eine 5 bedeutet dabei dass, das Ziel in naher Zukunft sehr nützlich/wichtig für die Software wäre ist. Eine tiefe Zahl sollte dabei, wenn möglich, auch einmal in die Software integriert werden und ist nicht unwichtig. #+CAPTION: Projektziele #+ATTR_LATEX: :environment longtable :align |p{1cm}|p{9cm}|p{1.5cm}|p{2cm}| #+NAME: tab:projektziele |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | *Ziel-Nr.*\cellcolor[HTML]{C0C0C0} | *Zielsetzung*\cellcolor[HTML]{C0C0C0} | *Muss*\cellcolor[HTML]{C0C0C0} | *Wunsch*\newline (1-5, 5=sehr wichtig)\cellcolor[HTML]{C0C0C0} | | <5> | <30> | <10> | <10> | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 1. | Die Anwendung setzt auf cross-plattform (Linux, Windows, OS X) fähige Technologien. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 2. | Die Anwendung steht unter der gls:gpl v3 der Öffentlichkeit zur Verfügung. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 3. | Der User kann mit weniger als 3 Klicks ein Backup ausführen. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 4. | Der User kann ein Archiv mit 3 Klicks löschen. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 5. | Der User kann unter Linux ein Archiv mit zwei Klicks "read-only" als Laufwerk mounten. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 6. | Der User kann ein Archiv wieder herstellen. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 7. | Der User kann den zu sichernden Pfad manuell in der Anwendung definieren. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 8. | Die Applikation holt ihre Konfiguration aus einer Plain-Text Datei. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 9. | Der User kann sein Repository auf einer Harddisk ablegen. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 10. | Die Anwendung exkludiert für einen Linux Computer sinnvolle Pfade bereits zu Beginn. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 11. | Die Archivliste wird nach einer Aktion automatisch aktualisiert. | x | | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 12. | Der User kann sein Repository auf einem über SSH erreichbaren Server ablegen. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 13. | Der User kann den Namen eines Archivs selbst bestimmen. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 14. | Die Anwendung meldet transparent, wenn das Repository nicht erreichbar ist. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 15. | Die Anwendung meldet dem User, wenn noch ein Hypervisor am Laufen ist. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 16. | Die Anwendung leitet Meldungen von gls:borg transparent weiter. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 17. | Die Anwendung zeigt transparent an das gls:borg im Hintergrund bereits läuft. | | 5 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 18. | Das Repository wird nach jedem Backup bereinigt. | | 4 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 19. | Der User kann automatische Hintergrundbackups in der Anwendung konfigurieren. | | 4 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 20. | Die Anwendung gibt dem User die Möglichkeit ein passendes Repository zu erstellen, wenn keines gefunden wird, die Anwendung jedoch bereits konfiguriert ist. | | 4 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 21. | Die Applikation verwendet, wann immer möglich allgemeingültige Umgebungsvariablen. | | 4 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 22. | Die Anwendung cached/speichert (evtl. zusätzliche) Informationen in einer Datenbank. | | 3 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 23. | Die Anwendung zeigt beim ersten Starten einen Setup Wizard. | | 3 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 24. | Der User kann sich mit 3 Klicks das Log eines Archivs anschauen. Nur möglich mit einer zusätzlichen DB. | | 3 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 25. | Die Anwendung kann Systembenachrichtigungen auslösen. | | 3 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 26. | Der User kann die Anwendung grafisch konfigurieren. | | 3 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 27. | Der User kann entscheiden ob, ein gemountetes Archiv nach dem Schliessen der Applikation noch weiter verfügbar ist. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 28. | Der User kann das Repository wechseln. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 29. | Der User kann ein Archiv nach einer Datei oder einem Ordner durchsuchen. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 30. | Der User kann die "Retention Policy" konfigurieren. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 31. | Die Anwendung kann mit allen Features von BorgBackup umgehen. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| | 32. | Die Applikation prüft, ob sie sich im richtigen Netzwerk befindet bevor sie eine Verbindung zum Server aufbaut. | | 2 | |------------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------+----------------------------------------------------------------| #+LATEX:\newpage ** Projektabgrenzung Die Anwendung beschränkt sich darauf Funktionen von gls:borg grafisch darzustellen oder nützlich zu erweitern soweit dies über die gls:api möglich ist. Wie in Abbildung:([[fig:kontext]]) zu sehen ist, werden die Aktionen effektiv immer vom Borg Binary ausgeführt und nicht von der grafischen Oberfläche. Eine Erweiterung von gls:borg ist nicht vorgesehen. Backup und Verschlüsselung sind heikle Themen und sollten unbedingt nur von Experten angegangen werden. Das Potenzial für Fehler und die Auswirkungen derer, sind einfach schlicht zu gross. Des Weiteren wird die Grundlage für eine kollaborative Entwicklung geschaffen. Während der Laufzeit der Diplomarbeit werden jedoch keine Inputs aus der Borg Community im Bezug auf die Entwicklung entgegengenommen. Bugs von gls:borg welche während der Dauer der Diplomarbeit vom Studenten entdeckt werden, wird dieser dem Projekt melden jedoch nicht selber beheben. #+caption: Kontextdiagramm des Borg GUI #+name: fig:kontext [[file:pictures/kontextdiagramm.pdf]] #+attr_latex: :center ** Projektmethode Für das Projekt wurde die Wasserfall-Methode gewählt. Da nur eine einzige Person am Projekt arbeitet, kann nur ein Task nach dem anderen abgearbeitet werden und viele Aufgaben stehen in Abhängigkeiten zueinander. Somit macht das iterative Vorgehen der Wasserfall-Methode für dieses Projekt am meisten Sinn. ** Konfigurationsmanagement In der nachfolgenden Sektion wird definiert wie die Software und Dokumentation versioniert wird und welche allgemeinen Werkzeuge eingesetzt werden. *** Versionskontrolle Die komplette Dokumentation, der Quellcode der Applikation sowie jegliche zusätzliche Dokumente wie etwa die Zeitplanung werden mittels der Software Git versioniert. Thematisch zusammengehörende Änderungen werden in einem Commit zusammengefasst. Somit ist jederzeit nachvollziehbar was wann geändert hat. Ein Commit sollte dabei gemäss dem Artikel von Chris Beams "How to write a Git Commit Message" footcite:commit und in englischer Sprache geschrieben sein. Versionsnummern sind für die Applikation zum jetzigen Zeitpunkt noch nicht vorgesehen. Sollten sie zukünftig einmal verwendet werden soll eine semantische Versionierung footcite:semver verwendet. Dabei ist eine Versionsnummer immer nach diesem Schema aufgebaut, MAJOR.MINOR.PATCH. Bei Änderungen wir die: 1. MAJOR Version erhöht, wenn man inkompatible Änderungen an der gls:api macht. 2. MINOR Version erhöht, wenn man Funktionalität hinzufügt, die abwärtskompatibel ist. 3. PATCH Version erhöht, wenn man abwärtskompatibel Bug-Fixes hinzufügt. Auf jeden Fall sollte, wenn möglich immer nur lauffähiger Code im Master Branch eingecheckt sein damit der Master Branch immer eine funktionierende Software repräsentiert. Dies gilt auch für das Repository der Dokumentation. Der Master Branch der Dokumentation sollte maximal mit zwei Befehlen ~make clean~ und ~make~ "kompilierbar" sein. Als Software für die Versionskontrolle wurde Git footcite:git aus folgenden Gründen ausgewählt: - Ist der de facto Standard bei Versionskontrollsoftware - Läuft auf allen gängigen Betriebssystemen - Es gäbe gratis Services, die man nutzen könnte (Github, Gitlab) - Man kann offline arbeiten und Commits erstellen - Der Autor hat bereits einen eigenen Git Server zur Verfügung - Der Autor ist bereits mit Git aus vorhergehenden Projekten vertraut, dadurch muss man keine Ressourcen aufwenden eine neue Software zu lernen. Zusätzlich hat sich Git in den vorhergehenden Projekten als robuste und schnelle Software erwiesen. - Git ist gls:libre unter der gls:gpl v2. *** Editor Sowohl bei der Dokumentation wie auch bei der Programmierung wurde hauptsächlich der Editor GNU Emacs footcite:emacs verwendet. GNU Emacs ist mit 32 Jahren (obwohl seine Wurzeln bis ins Jahre 1976 zurückgehen) wohl eines der ältesten noch aktiven Software Projekte. Emacs ist gls:libre unter der gls:gpl v3. Emacs wurde gewählt da es ein schneller, schlanker und sehr flexibler Texteditor ist. Von normaler Textmanipulation über Taskmanagement und Emails schreiben ist alles möglich. *** Dokumentation Diese Dokumentation wurde in Org-mode footcite:orgmode, einer Erweiterung für den Text Editor Emacs, geschrieben. Die Syntax erinnert an Markdown und Org-mode bietet einem eine Vielzahl an Hilfen dafür inklusive dem Erstellen von Tabellen und Spreadsheet Funktionen. Für finale Version des Dokuments kann Org-mode die ursprünglich Textdatei über LaTeX in ein PDF exportieren. LaTeX footcite:latex ist eine Software, welche einem die Benutzung des Textsatzsystems TeXs vereinfacht. LaTeX wurde gegenüber einem "What You See Is What You Get" (z.Bsp. MS. Word) Editor gewählt, weil es einem mit seiner Markup Sprache erlaubt das Dokument in Text Dateien zu erstellen, gerade für Programmiere ist dies eine sehr interessante Lösung. Dadurch, dass LaTeX auch nur aus reinen Textdateien besteht, kann man die Dokumente auch ohne weiteres in die Versionskontrollsoftware einchecken und die Entwicklung im Log zurückverfolgen. LaTeX ist gls:libre unter der LaTeX Project Public License. Die Grafiken in diesem Dokument wurden hauptsächlich mit dem Vektor Grafik Editor Inkscape footcite:inkscape erstellt. Inkscape ist gls:libre unter der GNU Public License v3. Die Diagramme wurden mit Draw.io footcite:draw erstellt. Draw.io ist gls:libre unter Apache Lizenz Version 2.0 footcite:apache und kann sowohl als Desktop Applikation wie auch als Webanwendung genutzt werden. Beim Design der Arbeit wurden soweit als möglich die typografischen Regeln aus dem Buch "Practical Typography" von Matthew Butterick footcite:typo angewandt. Bei den Diagrammen wurden ausschliesslich Farben aus der von Google entwickelten Design Sprache "Material" footcite:material eingesetzt. ** Zeitplanung Die detaillierte Zeitplanung ist dem Ganttchart in der Datei [[file:Zeitplanung_Andreas_Zweili.html][Zeitplanung_Andreas_Zweili.html]] zu entnehmen. Bei der Zeitplanung wurde darauf geachtet das die Arbeit soweit, als möglich nicht mit dem Berufsleben kollidiert An einem normalen Arbeitstag wurde dabei damit gerechnet das ca. 2 Stunden Arbeit am Abend möglich sein sollten. An einem arbeitsfreien Tag wurde mit 6 Stunden Arbeit gerechnet. Über die Festtage wurden diverse Tage von der Planung ausgenommen, da es nicht realistisch schien das an diesen Tagen die Arbeit signifikant vorwärtsgehen würde. Auch Schultage wurde nicht, als Arbeitstage gerechnet da man meist nicht mehr für weitere Tätigkeiten gross motiviert ist. Als zusätzliche Massnahme um die Arbeitslast zu verteilen wurde vom 14. Januar bis zum 11. März jeder Montag auf der Arbeitsstelle als frei eingegeben. Dadurch steht wägend des Projektes etwas mehr Zeit zur Verfügung als sonst mit einer 100 Prozent Arbeitsstelle möglich wäre. ** Controlling Das Controlling wird verwendet, um zu kontrollieren, dass die eigentliche Planung mit dem effektiv geleisteten Aufwand respektive den effektiv verwendeten Ressourcen übereinstimmt. Somit können für zukünftige Projekte Lehren gezogen werden. #+LATEX:\newpage #+LATEX:\begin{landscape} *** Zeit #+CAPTION: Zeitcontrolling #+ATTR_LATEX: :environment longtable :align |p{3cm}|p{5cm}|p{3cm}|p{7cm}| #+NAME: tab:zeitcontr |-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------| | *Aufgabe*\cellcolor[HTML]{C0C0C0} | *Gesch. Aufwand*\cellcolor[HTML]{C0C0C0} | *Effekt. Aufwand*\cellcolor[HTML]{C0C0C0} | *Begründung*\cellcolor[HTML]{C0C0C0} | |-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------| |-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------| | | *Gesamter Aufwand* | | | |-----------------------------------+------------------------------------------+-------------------------------------------+--------------------------------------| #+LATEX:\newpage *** Ressourcen Folgende Ressourcen werden während der Arbeit benötigt: #+CAPTION: Ressourcen #+ATTR_LATEX: :environment longtable :align |p{5cm}|p{3cm}|p{3cm}|p{7cm}| #+NAME: tab:zeitcontr |-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------| | *Ressource*\cellcolor[HTML]{C0C0C0} | *geschätzte Stück*\cellcolor[HTML]{C0C0C0} | *effekt. Stück*\cellcolor[HTML]{C0C0C0} | *Begründung*\cellcolor[HTML]{C0C0C0} | |-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------| | Projektleiter/Mitarbeiter | 1 | 1 | | | Diplombetreuer | 1 | 1 | | | Testuser | 5 | | | | Korrekturleser | 3 | | | | iPad | 1 | 1 | | | Notebook | 1 | 1 | | |-------------------------------------+--------------------------------------------+-----------------------------------------+--------------------------------------| #+LATEX:\end{landscape} *** Kosten Werden die internen Lohnkosten des Projektleiters auf ca. 60 CHF pro Stunde geschätzt ergeben sich aus der Zeitplanung somit theoretische Kosten von 19'200 CHF für die Umsetzung dieser Arbeit. Da dieses Projekt finanziell jedoch in keinster Weise wirtschaftliche relevant ist, sind die Kosten nur ein rein theoretischer Faktor. #+CAPTION: Kostenrechnung #+NAME: tab:kosten |--------------------------------+----------------------------------------+-----------------------------------------| | *Name*\cellcolor[HTML]{C0C0C0} | *Aufwand in h*\cellcolor[HTML]{C0C0C0} | *Kosten in CHF*\cellcolor[HTML]{C0C0C0} | |--------------------------------+----------------------------------------+-----------------------------------------| | Initialisierung | 24 | 1440 | | Analyse | 47 | 2820 | | Konzept | 34 | 2040 | | Realisierung | 172 | 10320 | | Ausblick | 8 | 480 | | Arbeit korrigieren | 20 | 1200 | | Meeting #1 | 5 | 300 | | Meeting #2 | 5 | 300 | | Meeting #3 | 5 | 300 | |--------------------------------+----------------------------------------+-----------------------------------------| | *Total* | 320 | 19200 | |--------------------------------+----------------------------------------+-----------------------------------------| #+TBLFM: @2$3=@2$2 * 60::@3$3=@3$2 * 60::@4$3=@4$2 *60::@5$3=@5$2 *60::@6$3=@6$2 *60::@7$3=@7$2 *60::@8$3=@8$2 *60::@9$3=@9$2 *60::@10$3=@10$2 *60 #+TBLFM: @>$2=vsum(@2..@-1) #+TBLFM: @>$3=vsum(@2..@-1) ** Projektrisiken Das Risikomanagement dient dazu Risiken im Projekt zu erkennen und Massnahmen zur Vermeidung der Risiken zu definieren. Dadurch steht man ihnen nicht unvorbereitet gegenüber, sollten sie eintreffen. *** Risikobeschreibung In der Tabelle: ([[tab:risikobeschreibung]]), sind die Risiken des Projektes gemeinsam mit ihren Gegenmassnahmen aufgelistet. Jedes Risiko wurde entsprechend der Tabelle: ([[tab:wahrscheinlichkeit]]) nach der Wahrscheinlichkeit des Eintreffens bewertet und entsprechend der Tabelle: ([[tab:auswirkung]]) nach seiner Auswirkung bewertet. #+CAPTION: Projektrisiken #+ATTR_LATEX: :environment longtable :align |p{0.45\textwidth}|p{0.45\textwidth}| :placement [H] #+NAME: tab:projektrisiken |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | <30> | <30> | | *Beschreibung*\cellcolor[HTML]{C0C0C0} | *Massnahmen*\cellcolor[HTML]{C0C0C0} | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | Ein grösseres Problem in der Programmierung blockiert den Fortschritt. | Immer nur eine Sache auf einmal in der Code-Basis ändern, alle Fehler beheben und erst dann zur nächsten Aufgabe weitergehen. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | Viel Arbeit an der Arbeitsstelle, dabei bleibt weniger Zeit für die Diplomarbeit. | Auf der Arbeit Freitage eingeben um die Last etwas zu verteilen. Projektplanung machen. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | Know-How zur Umsetzung ist nicht vollständig vorhanden. | Gute Informationsbeschaffung im Internet, Büchern, etc. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | Manuelle Tests brauchen zu viel Zeit. | Soviel wie möglich automatisieren. Dabei jedoch nicht den Fokus auf die eigentliche Entwicklung verlieren. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | Die Programmierung des Programms benötigt zu viel Zeit. | Bei der Projektplanung genau definieren was die GUI Applikation beinhalten muss. Ziele definieren, Abgrenzungen treffen. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | User haben keine Zeit für Utility Tests. | Vor gängig einen Termin abmachen. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| | gls:borg ändert fundamental seine gls:api. | Gegen eine fixe Version von gls:borg entwickeln. | |-----------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------| * Analyse ** Umweltanalyse Die Projektumwelt-Analyse ist eine Methode, die Beziehungen, Erwartungshaltungen und Einflüsse auf das Projekt durch interne und externe soziale Umwelt zu betrachten und zu bewerten. Auf Grundlage der Analyseergebnisse werden erforderliche Massnahmen zur Gestaltung der Umweltbeziehungen abgeleitet. Die Gestaltung der Projektumweltbeziehungen ist eine Projektmanagementaufgabe. In der Tabelle:([[tab:umweltanalyse]]) wurden die Anforderungen und Wünsche mit Einschätzung der Wahrscheinlichkeit und der Einflussnahme aufgenommen. Zusätzlich ist die Beziehung der Stakeholder zum Projekt noch in der Abbildung:([[fig:umweltgrafik]]) grafisch dargestellt. Da das Projekt so ausgelegt ist das der Projektleiter es in Eigenarbeit verwirklichen kann ist der Einfluss der Stakeholder während der Umsetzung sehr gering. Die User werden bei der Entwicklung mittels einer "Usability" Studie miteinbezogen und die gls:borg Community wird mit regelmässigen Posts auf dem offiziellen Github Repository auf dem Laufenden gehalten. Nach Ende der Diplomarbeit soll das Projekt für interessierte Entwickler jedoch offen sein. Der Quellcode wird bereits während der Arbeit öffentlich zur Verfügung gestellt. #+CAPTION: Stakeholder Diagramm #+ATTR_LATEX: :width .9\textwidth #+NAME: fig:umweltgrafik [[file:pictures/stakeholder_diagramm.pdf]] #+LATEX:\newpage #+LATEX:\begin{landscape} #+CAPTION: Umwelt-Analyse #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{0.8cm}|l|l|p{8cm}|l| #+NAME: tab:umweltanalyse |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| | <5> | <20> | <20> | | | | *Nr*.\cellcolor[HTML]{C0C0C0} | *Stakeholder*\cellcolor[HTML]{C0C0C0} | *Einfluss*\cellcolor[HTML]{C0C0C0} | *Anforderung/Wünsche*\cellcolor[HTML]{C0C0C0} | *Wahrscheinlichkeit*\cellcolor[HTML]{C0C0C0} | |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| | 1. | BorgBackup Community | gering | - Eine Applikation die den Umfang von BorgBackup abdeckt | mittel | | | | | - Open-Source | hoch | | | | | - Mitsprachrecht bei der Entwicklung | niedrig | |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| | 2. | User | gering | - Eine einfache Anwendung | hoch | | | | | - Einmal einrichten und vergessen | mittel | |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| | 3. | Interessenten | gering | - Einfach verständliches Projekt Repository | hoch | | | | | - Einfaches Setup zum testen | hoch | |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| | 4. | Projektleiter | hoch | - Stabile Anwendung erstellen | mittel | | | | | - Ein nachhaltiges Projekt starten | mittel | | | | | - Anerkennung im fachlichen Umfeld | hoch | |-------------------------------+---------------------------------------+------------------------------------+----------------------------------------------------------+----------------------------------------------| #+LATEX:\end{landscape} ** Risiko-Analyse Bei der Risiko-Analyse wird von einem durchschnittlichen Benutzer ausgegangen, der zur Zeit noch keine Backups macht und beginnen möchte gls:borg zu nutzen, um auf einer externen Harddisk seine Backups zu speichern. Es wird dabei eine Ist/Soll Analyse gemacht, um die Lösung gegenüber der bestehenden Möglichkeiten zu vergleichen. Jedes Risiko wurde entsprechend der Tabelle: ([[tab:wahrscheinlichkeit]]) nach der Wahrscheinlichkeit des Eintreffens bewertet und entsprechend der Tabelle: ([[tab:auswirkung]]) nach seiner Auswirkung im Bezug auf die Nützlichkeit der gemachten Backups. In der Tabelle: ([[tab:risikobeschreibung]]) sind dabei die Risiken für das Szenario aufgelistet und nummeriert. In der Abbildung:([[fig:istrisiko]]), ist die Bewertung des Ist-Risikos grafisch dargestellt und in der Abbildung:([[fig:sollrisiko]]), ist das Soll-Risiko welches mit dieser Arbeit angestrebt wird ebenfalls grafisch dargestellt. Es sollte im Rahmen der Arbeit möglich sein die meisten Risiken zu verringern. Da automatische Hintergrundbackups jedoch nur ein Kann-Ziel sind wir in dieser Analyse nicht davon ausgegangen das man das Risiko Nr. 5 im Rahmen dieser Arbeit reduzieren kann. #+CAPTION: Risikobewertung Wahrscheinlichkeit #+ATTR_LATEX: :align l|l :placement [H] #+NAME: tab:wahrscheinlichkeit | *Bewertung* | *Beschreibung: Wahrscheinlichkeit (W)* | |-------------+----------------------------------------| | 1 = gering | Unwahrscheinlich, <20% | | 2 = mittel | Mässig wahrscheinlich, 20-50% | | 3 = hoch | Hohe Wahrscheinlichkeit > 50% | #+CAPTION: Risikobewertung Auswirkung #+ATTR_LATEX: :align l|l :placement [H] #+NAME: tab:auswirkung | *Bewertung* | *Beschreibung: Auswirkung (A)* | |-------------+------------------------------------------| | 1 = gering | Geringe Auswirkungen auf Nützlichkeit | | 2 = mittel | Mittlere Auswirkung auf die Nützlichkeit | | 3 = hoch | Hohe Auswirkung auf die Nützlichkeit | #+CAPTION: Risikobeschreibung #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{0.1\textwidth}|p{0.8\textwidth}| :placement [H] #+NAME: tab:risikobeschreibung |-------------------------------+---------------------------------------------------------------------------------------------------------------| | <10> | <30> | | *Nr.*\cellcolor[HTML]{C0C0C0} | *Beschreibung*\cellcolor[HTML]{C0C0C0} | |-------------------------------+---------------------------------------------------------------------------------------------------------------| | 1. | Der Benutzer hat noch nie die Kommandozeile verwendet und scheitert bereits an der Installation von gls:borg. | |-------------------------------+---------------------------------------------------------------------------------------------------------------| | 2. | Der Benutzer verwendet keine Verschlüsselung und verliert seine Harddisk. | |-------------------------------+---------------------------------------------------------------------------------------------------------------| | 3. | Der Benutzer speichert die Backups auf der internen statt der externen Harddisk. | |-------------------------------+---------------------------------------------------------------------------------------------------------------| | 4. | Der Benutzer löscht aus Versehen ein Backup. | |-------------------------------+---------------------------------------------------------------------------------------------------------------| | 5. | Der Anwender vergisst die Backups zu machen. | |-------------------------------+---------------------------------------------------------------------------------------------------------------| #+CAPTION: Grafische Darstellung der Ist-Risikoanalyse #+ATTR_LATEX: :width 9cm :placement [H] #+NAME: fig:istrisiko [[file:pictures/istrisiko.pdf]] #+CAPTION: Grafische Darstellung der Soll-Risikoanalyse #+ATTR_LATEX: :width 9cm :placement [H] #+NAME: fig:sollrisiko [[file:pictures/sollrisiko.pdf]] #+LATEX:\newpage ** SWOT-Analyse Die SWOT-Analyse ist eine Methode, die Stärken, Schwächen, Chancen und Gefahren zu erkennen, indem eine 4-Felder-Matrix ausgefüllt wird. Wichtig vor dem Ausfüllen der SWOT-Analyse ist es, ein klares Ziel zu haben. Die ausgefüllte SWOT-Analyse für dieses Projekt ist in der Abbildung:([[fig:swot]]) zu sehen. #+caption: SWOT Analyse des Projektes #+name: fig:swot [[file:pictures/swot_analyse.pdf]] #+attr_latex: :center :width 0.9\textwidth ** Anforderungskatalog Der Anforderungskatalog entspricht 1 zu 1 den Zielen, welche in der Tabelle [[tab:projektziele]] definiert wurden. ** Use Cases Ein Use Case sammelt alle möglichen Szenarien, die eintreten können, wenn ein Akteur versucht, mithilfe des betrachteten Systems ein bestimmtes Ziel zu erreichen. Dabei beschreibt er, was beim Versuch der Zielerreichung passieren kann. Je nach Ablauf kann auch ein Fehlschlag ein Ergebnis eines Anwendungsfalls sein (e.g. falsches Passwort beim Login). Dabei wird die technische Lösung nicht konkret beschrieben. Die Detailstufe kann dabei sehr unterschiedlich sein.footcite:usecase *** Anwendungsfalldiagramm "Ein Anwendungsfalldiagramm ... ist eine der 14 Diagrammarten der Unified Modelling Language (UML), einer Sprache für die Modellierung der Strukturen und des Verhaltens von Software- und anderen Systemen. Es stellt Anwendungsfälle und Akteure mit ihren jeweiligen Abhängigkeiten und Beziehungen dar."\footcite{usecasediagramm} Das Anwendungsfalldiagramm für das gls:borg gls:gui ist in der Abbildung: ([[fig:usecase]]) zu sehen. #+LATEX:\newpage #+LATEX:\begin{landscape} #+CAPTION: Anwendungsfalldiagramm #+ATTR_LATEX: :height.9\textwidth #+NAME: fig:usecase [[file:pictures/use_case.pdf]] #+LATEX:\end{landscape} #+LATEX:\newpage *** Use Cases Detailbeschreibung Use Cases werden in der Regel mithilfe einer sogenannten Use Case Schablone im Detail beschrieben, damit klar ist, wie der Ablauf jeweils genau aussieht. Die in diesem Projekt verwendete Schablone wurde von Alistair Cockburn definiert. Die nachfolgend aufgeführten Use Cases, Tabellen:([[tab:uc_backup]], [[tab:uc_delete]], [[tab:uc_restore]], [[tab:uc_file]], [[tab:uc_mount]], [[tab:uc_config]], [[tab:uc_automatic]]) wurden dem Anwendungsfalldiagramm, Abbildung:([[fig:usecase]]), entnommen und zusätzlich noch um jeweils ein Aktivitätsdiagramm, Abbildungen: ([[fig:activity_backup]], [[fig:activity_delete]], [[fig:activity_restore]], [[fig:activity_mount]], [[fig:activity_settings]], [[fig:activity_automatic]]), erweitert um den Ablauf verständlicher zu machen. Ein Aktivitätsdiagramm ist dabei ein hilfreiches UML Diagramm zum Erweitern von Use Cases und zeigt einem gut die Zuständigkeiten der Aktoren auf. **** Use Case 1.0 Backup erstellen #+LATEX:{\footnotesize #+CAPTION: Use Case 1.0 Backup erstellen #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_backup |---------------------+---------------------------------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 1.0 Backup erstellen | |---------------------+---------------------------------------------------------------------------------------------| | *Description* | Das erstellen einer Datensicherung durch gls:borg anstossen. | |---------------------+---------------------------------------------------------------------------------------------| | *Actors* | Benutzer | |---------------------+---------------------------------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+---------------------------------------------------------------------------------------------| | *Includes* | - | |---------------------+---------------------------------------------------------------------------------------------| | *Trigger* | User möchte ein Backup erstellen. | |---------------------+---------------------------------------------------------------------------------------------| | *Preconditions* | Die Applikation wurde gestartet. | |---------------------+---------------------------------------------------------------------------------------------| | *Postconditions* | Das erstellte Backup wird angezeigt. | |---------------------+---------------------------------------------------------------------------------------------| | *Normal Flow* | 1. Den Quellpfad auswählen. | | | 2. Den Button "Backup" anklicken. | | | 3. Ein Pop mit Fortschrittsbalken erscheint und zeigt die Zeit bis zum Ende des Backups an. | | | 4. Am Ende des Backups verschwindet das Pop-up wieder. | | | 5. Die Liste der Backups aktualisiert sich. | |---------------------+---------------------------------------------------------------------------------------------| | *Alternative Flow* | - | |---------------------+---------------------------------------------------------------------------------------------| | *Notes* | - | |---------------------+---------------------------------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+---------------------------------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+---------------------------------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+---------------------------------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm zum Erstellen eines Backups #+name: fig:activity_backup [[file:pictures/activity_backup.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage **** Use Case 2.0 Backup löschen #+LATEX:{\footnotesize #+CAPTION: Use Case 2.0 Backup löschen #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_delete |---------------------+------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 2.0 Backup löschen | |---------------------+------------------------------------------------------------------| | *Description* | Ein zuvor erstelltes Backup wird gelöscht. | |---------------------+------------------------------------------------------------------| | *Actors* | Benutzer | |---------------------+------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+------------------------------------------------------------------| | *Includes* | - | |---------------------+------------------------------------------------------------------| | *Trigger* | Ein User möchte ein bestehendes Backup löschen. | |---------------------+------------------------------------------------------------------| | *Preconditions* | Use Case 1.0 ausgeführt. | |---------------------+------------------------------------------------------------------| | *Postconditions* | Das gelöschte Backup wird nicht mehr aufgelistet. | |---------------------+------------------------------------------------------------------| | *Normal Flow* | 1. Ein Backup aus der Liste auswählen. | | | 2. Den Button "Delete anklicken". | | | 3. Ein Bestätigungsdialog erscheint. | | | 4. Im Dialog den "Ok" Button anklicken. | |---------------------+------------------------------------------------------------------| | *Alternative Flow* | 1. Ein Backup aus der Liste auswählen. | | | 2. Den Button "Delete anklicken". | | | 3. Ein Bestätigungsdialog erscheint. | | | 4. Die Aktion mit einem Klick auf den "Cancel" Button abbrechen. | |---------------------+------------------------------------------------------------------| | *Notes* | - | |---------------------+------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm zum Löschen eines Backups #+name: fig:activity_delete [[file:pictures/activity_delete.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage **** Use Case 3.0 Backup wiederherstellen #+LATEX:{\footnotesize #+CAPTION: Use Case 3.0 Backup wiederherstellen #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_restore |---------------------+--------------------------------------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 3.0 Backup wiederherstellen | |---------------------+--------------------------------------------------------------------------------------------------| | *Description* | Alle Dateien eines Backups wiederherstellen. | |---------------------+--------------------------------------------------------------------------------------------------| | *Actors* | User | |---------------------+--------------------------------------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+--------------------------------------------------------------------------------------------------| | *Includes* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *Trigger* | Daten sollen wieder hergestellt werden. | |---------------------+--------------------------------------------------------------------------------------------------| | *Preconditions* | Use Case 1.0 wurde ausgeführt. | |---------------------+--------------------------------------------------------------------------------------------------| | *Postconditions* | Die Dateien aus dem Backup wurde im angegeben Pfad wiederhergestellt. | |---------------------+--------------------------------------------------------------------------------------------------| | *Normal Flow* | 1. Ein Backup aus der Liste auswählen. | | | 2. Den Button "Restore" klicken. | | | 3. Ein Pop-up zur Auswahl eines Zielpfades erscheint. | | | 4. Den Zielpfad mit klick auf "Choose" bestätigen. | | | 5. Ein Dateiexplorer öffnet sich mit dem ausgewählt Pfad und enthält die Dateien aus dem Backup. | |---------------------+--------------------------------------------------------------------------------------------------| | *Alternative Flow* | 1. Ein Backup aus der Liste auswählen. | | | 2. Den Button "Restore" klicken. | | | 3. Ein Pop-up zur Auswahl eines Zielpfades erscheint. | | | 4. Die Aktion mit klick auf "Cancel" abbrechen. | |---------------------+--------------------------------------------------------------------------------------------------| | *Notes* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+--------------------------------------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+--------------------------------------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+--------------------------------------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm zum Wiederherstellen eines Backups #+name: fig:activity_restore [[file:pictures/activity_restore.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage **** Use Case 4.0 Einzelne Datei wiederherstellen #+LATEX:{\footnotesize #+CAPTION: Use Case 4.0 Einzelne Datei wiederherstellen #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_file |---------------------+--------------------------------------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 4.0 Einzelne Datei wiederherstellen | |---------------------+--------------------------------------------------------------------------------------------------| | *Description* | Das spezifische Wiederherstellen von einer oder mehreren Dateien. | |---------------------+--------------------------------------------------------------------------------------------------| | *Actors* | User | |---------------------+--------------------------------------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+--------------------------------------------------------------------------------------------------| | *Includes* | Use Case 4.1 | |---------------------+--------------------------------------------------------------------------------------------------| | *Trigger* | Daten sollen wieder hergestellt werden. | |---------------------+--------------------------------------------------------------------------------------------------| | *Preconditions* | Use Case 1.0 wurde ausgeführt. | |---------------------+--------------------------------------------------------------------------------------------------| | *Postconditions* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *Normal Flow* | 1. Ein Backup aus der Liste auswählen. | | | 2. Auf den Button "Mount" klicken. | | | 3. Use Case 4.1 wird ausgeführt. | | | 4. Ein Dateiexplorer öffnet sich mit dem ausgewählt Pfad und enthält die Dateien aus dem Backup. | | | 5. Wird die Applikation geschlossen wird das Backup ausgehängt. | |---------------------+--------------------------------------------------------------------------------------------------| | *Alternative Flow* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *Notes* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+--------------------------------------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+--------------------------------------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+--------------------------------------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm für das spezifische Wiederherstellen einer Datei #+name: fig:activity_mount [[file:pictures/activity_mount.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage **** Use Case 4.1 Backup mounten #+LATEX:{\footnotesize #+CAPTION: Use Case 4.1 Backup mounten #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_mount |---------------------+-----------------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 4.1 Backup mounten | |---------------------+-----------------------------------------------------------------------------| | *Description* | Ein Backup wird als FUSE gemountet. | |---------------------+-----------------------------------------------------------------------------| | *Actors* | Borg GUI, gls:borg | |---------------------+-----------------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+-----------------------------------------------------------------------------| | *Includes* | - | |---------------------+-----------------------------------------------------------------------------| | *Trigger* | Das Borg GUI gibt an gls:borg den Input zum mounten weiter. | |---------------------+-----------------------------------------------------------------------------| | *Preconditions* | Use Case 1.0 wurde ausgeführt. | |---------------------+-----------------------------------------------------------------------------| | *Postconditions* | Das Backup wurde gemountet. | |---------------------+-----------------------------------------------------------------------------| | *Normal Flow* | 1. Borg GUI sammelt die Backup ID in Use Case 4.0. | | | 2. Borg GUI übergibt die Backup ID an gls:borg zusammen mit einem Zielpfad. | | | 3. gls:borg hängt das Backup als FUSE Laufwerk am Zielpfad ein. | | | 4. gls:borg meldet Erfolg an Borg GUI. | |---------------------+-----------------------------------------------------------------------------| | *Alternative Flow* | 1. Borg GUI sammelt die Backup ID in Use Case 4.0. | | | 2. Borg GUI übergibt die Backup ID an gls:borg zusammen mit einem Zielpfad. | | | 3. gls:borg hängt das Backup als FUSE Laufwerk am Zielpfad ein. | | | 4. gls:borg meldet einen Fehler an Borg GUI. | |---------------------+-----------------------------------------------------------------------------| | *Notes* | - | |---------------------+-----------------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+-----------------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+-----------------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+-----------------------------------------------------------------------------| #+LATEX:} #+LATEX:\newpage **** Use Case 5.0 Konfiguration ändern #+LATEX:{\footnotesize #+CAPTION: Use Case 5.0 Konfiguration ändern #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_config |---------------------+--------------------------------------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 5.0 Konfiguration ändern | |---------------------+--------------------------------------------------------------------------------------------------| | *Description* | Das Verändern und Speichern der Konfiguration der Applikation. | |---------------------+--------------------------------------------------------------------------------------------------| | *Actors* | User | |---------------------+--------------------------------------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+--------------------------------------------------------------------------------------------------| | *Includes* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *Trigger* | Ein User möchte die Einstellungen der Applikation anpassen. | |---------------------+--------------------------------------------------------------------------------------------------| | *Preconditions* | Applikation gestartet. | |---------------------+--------------------------------------------------------------------------------------------------| | *Postconditions* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *Normal Flow* | 1. Auf den Button "Settings" klicken. | | | 2. Ein neues Fenster mit den Einstellungen öffnet sich. | | | 3. Der Benutzer ändert mindestens eine Einstellung. | | | 4. Der Button "OK" wird angeklickt. | | | 5. Die Konfiguration wird in die Konfigurationsdatei geschrieben und in der Applikation geladen. | |---------------------+--------------------------------------------------------------------------------------------------| | *Alternative Flow* | 1. Auf den Button "Settings" klicken. | | | 2. Ein neues Fenster mit den Einstellungen öffnet sich. | | | 3. Der Benutzer kann Einstellungen ändern. | | | 4. Der Button "Cancel" wird angeklickt. | | | 5. Jegliche Änderungen werden verworfen und die Konfigurationsdatei bleibt im aktuellen Zustand. | |---------------------+--------------------------------------------------------------------------------------------------| | *Notes* | - | |---------------------+--------------------------------------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+--------------------------------------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+--------------------------------------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+--------------------------------------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm zum Ändern von Einstellungen #+name: fig:activity_settings [[file:pictures/activity_settings.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage **** Use Case 6.0 automatische Backups aktivieren #+LATEX:{\footnotesize #+CAPTION: Use Case 6.0 automatische Backups aktivieren #+ATTR_LATEX::environment longtable :align |>{\columncolor[HTML]{EFEFEF}}p{.235\textwidth}|p{.7\textwidth}| :placement [H] #+NAME: tab:uc_automatic |---------------------+-----------------------------------------------------------------------| | | <30> | | *Identifier + Name* | 6.0 automatische Backups aktivieren | |---------------------+-----------------------------------------------------------------------| | *Description* | Ein Systemdienst wird hinterlegt zum ausführen automatischer Backups. | |---------------------+-----------------------------------------------------------------------| | *Actors* | User | |---------------------+-----------------------------------------------------------------------| | *Status* | Freigegeben | |---------------------+-----------------------------------------------------------------------| | *Includes* | - | |---------------------+-----------------------------------------------------------------------| | *Trigger* | Ein User möchte automatisierte Backups haben. | |---------------------+-----------------------------------------------------------------------| | *Preconditions* | Eine funktionierende Konfiguration muss hinterlegt sein. | | | Applikation gestartet. | |---------------------+-----------------------------------------------------------------------| | *Postconditions* | Ein Systemdienst wurde erstellt welcher jeden Tag ein Backup macht. | |---------------------+-----------------------------------------------------------------------| | *Normal Flow* | 1. Auf den Button "Settings" klicken. | | | 2. Bei der Option "Automatic Backups" den Hacken setzen. | | | 3. Die Settings mit klick auf "Ok" schliessen und speichern. | |---------------------+-----------------------------------------------------------------------| | *Alternative Flow* | 1. Auf den Button "Settings" klicken. | | | 2. Bei der Option "Automatic Backups" den Hacken setzen. | | | 3. Die Aktion mit klick auf "Cancel" abbrechen | |---------------------+-----------------------------------------------------------------------| | *Notes* | - | |---------------------+-----------------------------------------------------------------------| | *UC History* | 1.0 Draft erstellt durch AZ | |---------------------+-----------------------------------------------------------------------| | *Author* | A. Zweili | |---------------------+-----------------------------------------------------------------------| | *Date* | 30.12.2018 | |---------------------+-----------------------------------------------------------------------| #+LATEX:} #+caption: Aktivitätsdiagramm zum Aktivieren von automatischen Backups #+name: fig:activity_automatic [[file:pictures/activity_automatic.pdf]] #+attr_latex: :center :placement [H] #+LATEX:\newpage * Konzept ** Varianten Da Borg eine JSON API zur Verfügung stellt bieten sich diverse Möglichkeiten, um das Programm anzubinden. Da das Ziel ist, das Programm normalen Nutzern zugänglicher zu machen, bietet sich ein normales Desktop Programm am ehesten an. Desktop Programme werden von allen Computer Usern täglich genutzt und sind somit etwas was sie kennen. Daraus ergeben sich die in diesem Kapitel aufgeführten Möglichkeiten für das Projekt. *** Bewertung Die Bewertungspunkte setzen sich einerseits aus den Projektzielen anderseits aus für das Projekt sinnvollen Punkten zusammen. Dadurch ergeben sich dann die Bewertungen, welche in der nachfolgenden Tabelle aufgenommen wurden. Die möglichen Varianten wurden danach bewertet. Die effektive Berechnung des Resultats wird nach folgender Formel durchgeführt. \begin{equation} G * EP = KE \end{equation} Also die Gewichtung(/G/) multipliziert mit der erreichten Punktzahl(/EP/) ergibt das Kriteriumsergebnis(/KE/). Für das Endresultat wird dann die Summe über alle Kriterien gebildet. Die Variante mit der höchsten Summe wurde für das Projekt ausgewählt. Mussziele erhalten dabei eine Gewichtung von 10 und Wunschziele eine Gewichtung entsprechend der Bewertung in der Tabelle Projektziele ([[tab:projektziele]]). #+CAPTION: Muster Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:muster |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 10 | 50 | | 4. Integriert sich gut ins System | 5 | 10 | 10 | 50 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 10 | 50 | | 6. Lesbarkeit des Codes | 5 | 5 | 5 | 25 | | 7. Einfachheit des Setups | 5 | 5 | 5 | 25 | | 8. Lernfaktor | 5 | 5 | 5 | 25 | | 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 5 | 25 | | 10. Geschwindigkeit der Entwicklung | 3 | 5 | 5 | 15 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | *Total* | | | | 415 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4 #+TBLFM: @>$5=vsum(@3..@-1) *** Backend Fürs Backend bieten sich die folgende drei Sprachen an: [[C#][C#]], [[C++][C++]], [[Python][Python]]. Dies vor allem, weil alle Allrounder Sprachen sind und sich gut für Desktop Applikationen eignen. **** C# C# ist eine von Microsoft entwickelte Programmiersprache welche viele Frameworks zur Verfügung hat. Insbesondere aufgrund der grossen kommerziellen Nutzung und der guten Integration mit Windows hat C# eine relative grosse Verbreitung. Bei Linux und OS X ist es jedoch schwieriger C# zu integrieren und zu nutzen. Sie ist zu Teilen gls:libre. Die Common Language Runtime, welche für das Ausführen von Software zuständig ist, ist unter der MIT Lizenz lizenziert footcite:csharp der aktuelle Compiler Roslyn ist unter der Apache Lizenz verfügbar footcite:roslyn. Da es sehr viele offizielle Teile um die Sprache C# gibt, kann im Rahmen des Projektes nicht direkt abgeschätzt werden, ob alle benötigten Teile gls:libre sind. Für die Bewertung wird deshalb ein kleinerer Wert als bei C++ und Python genommen. C# ist die Programmiersprache, welche an der IBZ hauptsächlich gelehrt wird. Dadurch sind die Kenntnisse der Sprache und ihrer Anwendung bereits einigermassen vorhanden. Ausserhalb der Schule wurde die Sprache jedoch noch nie eingesetzt. Entwickelt wird C# hauptsächlich mit der gls:ide Microsoft Visual Studio. Eine sehr umfangreiche und komplexe Software. Visual Studio ist dabei nur für Windows und OS X erhältlich. Es ist auch möglich C# Projekte ausserhalb von Visual Studio zu erstellen, es ist jedoch nicht sehr einfach. Der Code ist gut lesbar und es gibt offizielle Styleguides von Microsoft was den Code über Projekte hinaus einigermassen einheitlich aussehen lässt. Zudem hilft hier auch Visual Studio stark den Code entsprechend zu formatieren. Besonders angenehm sind die Klassen- und Methodennamen der offiziellen Frameworks. Insgesamt sehr gut gelöst aber in Sachen Lesbarkeit noch etwas hinter Python. Unter Windows ist das Setup von C# relativ einfach. Allerdings ist es auch dort im Vergleich zu Python eine umfangreiche Angelegenheit Visual Studio sauber zu installieren und nutzbar zu machen. Auf anderen Plattform wird dies leider nicht einfacher und unter Linux ist es bereits schwierig eine funktionierende Umgebung in Gang zu bringen. Da C# bereits an der IBZ gelernt wird, ist der Lernfaktor hier im Vergleich zu den anderen Sprachen sicher am kleinsten. Allerdings gibt es noch keinerlei Kenntnisse beim Einbinden eines der unten aufgeführten gls:gui Frameworks. Daher gibt es auf jeden Fall noch genügend zu lernen. Die gls:borg Community hat vor relativ kurzer Zeit die offizielle Unterstützung von Windows zurückgezogen. Da C# eine sehr Windows lastige Sprache ist, wird daher davon ausgegangen das die Sprache innerhalb der gls:borg Community nicht sehr verbreitet ist. C# ist eine stark typisiert Sprache und kompilierte Sprache. Des Weiteren ist Visual Studio der Erfahrung nach nicht die schnellste Software. Dies alles führt dazu das C# nicht gerade die schnellste Sprache zum Programmieren ist. Jedoch aufgrund des moderneren Unterbaus sicher schneller als C++. #+CAPTION: C# Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:csharp |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 8 | 80 | | 2. Freie Software | 5 | 10 | 8 | 40 | | 3. Vorkenntnisse | 5 | 10 | 6 | 30 | | 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 6 | 30 | | 6. Lesbarkeit des Codes | 5 | 5 | 4 | 20 | | 7. Einfachheit des Setups | 5 | 5 | 2 | 10 | | 8. Lernfaktor | 5 | 5 | 3 | 15 | | 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 1 | 5 | | 10. Geschwindigkeit der Entwicklung | 3 | 5 | 3 | 9 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | *Total* | | | | 279 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4 #+TBLFM: @>$5=vsum(@3..@-1) **** C++ C++ ist eine stark typisierte und kompilierte Programmiersprache. Sie ist seit 1998 Teil des ISO Standards footcite:cpp98. ISO/IEC 14882:2017 footcite:cpp17 ist zurzeit die aktuellste Variante. Die Sprache existiert seit ca. 33 Jahren und hat eine weitreichende Verbreitung gefunden. C++ ist auf allen Betriebssystemen gut unterstützt muss jedoch für jedes System separat kompiliert werden. Von C++ sind innerhalb des Projektes keinerlei Vorkenntnisse vorhanden. Dies ist ein sehr hoher Risikofaktor. C++ kompiliert direkt zu Maschinensprache und ist dadurch sehr performant und läuft sehr gut auf jedem System. C++ ist im Vergleich zu modernen Sprachen jedoch relativ komplex und bietet diverse Stolpersteine für Programmierer. Zum Entwickeln braucht es verhältnismässig wenig. Da die Sprache bereits sehr alt ist, stammt sie noch aus einer Zeit wo man noch etwas rudimentärer programmierte. Allerdings braucht man in jedem Fall einen gls:compiler um ein ausführbares Programm zu erzeugen. Bei komplexeren Programmen wird man um mindestens so etwas wie glspl:makefile auch nicht herumkommen Im Vergleich zu Python oder C# ist C++ wohl die am schwersten lesbare Sprache. Zudem gibt es auch keinen zentralen Styleguide, welcher einem vorgeben würde wie der Code am besten ausschauen sollte. Somit haben sich über die Jahre mehrere Standards etabliert. Der Lernfaktor wäre aufgrund der mangelnden Vorkenntnisse hier ganz klar am Grössten. Da C++ eine alte Sprache ist geniesst sie auch eine dementsprechende Verbreitung. Daher ist anzunehmen das sicher mindestens ein grössere Teil der älteren BorgBackup Entwickler C++ oder C gelernt haben. Da C++ auch heute noch zu den meistgenutzten Sprachen gehört gibt es entsprechend viele Ressourcen dazu und Beispiel Projekte, von denen man ableiten kann. Auch hilfreiche Libraries gibt es sehr viele, welche den Programmierer unterstützen können. Die Sprache selber ist jedoch eher umständlich zu schreiben. Hinzu kommt noch das man, während der Entwicklung immer wieder den Code kompilieren muss. In einem Projekt mit dieser begrenzten Zeitspanne eher ungeeignet. #+CAPTION: C++ Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:cpp |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- -ergebnis*\cellcolor[HTML]{C0C0C0} | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 8 | 80 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 0 | 0 | | 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 6 | 30 | | 6. Lesbarkeit des Codes | 5 | 5 | 2 | 10 | | 7. Einfachheit des Setups | 5 | 5 | 3 | 15 | | 8. Lernfaktor | 5 | 5 | 5 | 25 | | 9. Verbreitung bei der BorgBackup Community | 5 | 5 | 3 | 15 | | 10. Geschwindigkeit der Entwicklung | 3 | 5 | 2 | 6 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | *Total* | | | | 271 | |---------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4 #+TBLFM: @>$5=vsum(@3..@-1) **** Python Der Python Interpreter ist für eine Vielzahl an Betriebssystemen erhältlich, inklusive Windows, OS X und Linux. Nahezu jedes Desktop Linux System kommt mit Python vor installiert. Auch OS X kommt bereits ab Werk mit Python Version 2. Version 3 lässt sich sehr einfach nachinstallieren und ist einfach nutzbar. Unter Windows gestaltetet sich die Installation etwas aufwendiger aber auch nicht sehr kompliziert. Python integriert sich in Windows jedoch etwas weniger elegant als C#. Python ist freie Software unter der Python Software Foundation License footcite:python und wird durch die Python Software Foundation in einem Community basierten Modell entwickelt. Die Vorkenntnisse sind im Vergleich zu C++ relativ gross und zu C# etwas weniger ausgeprägt. Es wurden damit im Rahmen der Ausbildung schon ein grösseres Projekt realisiert und ansonsten mehrere kleine Projekte im Privaten erstellen. Für Python gibt es ein paar glspl:ide welchen den Programmierer bei seiner Arbeit unterstützen können. Keine davon ist allerdings ein Muss um Python programmieren zu können. Im einfachsten Fall wäre dies mit Notepad möglich. Ein Editor mit etwas fortgeschritteneren Features wäre jedoch empfehlenswert. Python unterstützt mehrere Programmierungsparadigmen wie etwa objektorientiert, funktionale oder Prozedurale Paradigmen. Bei der Entwicklung von Python wurde sehr grossen Wert auf die Lesbarkeit der Sprache gelegt. Dies mit dem Hintergedanken das eine Programmiersprache viel häufiger gelesen als effektiv geschrieben wird footcite:pep8. Um ein Python Programm zu starten braucht es eigentlich kein grosses Setup. Solange die Abhängigkeiten vorhanden sind, kann man ein Skript mit einem einfachen Befehl, Code Snippet ([[code:minimal_python]]) starten. #+caption: Minimal Python Setup #+name: code:minimal_python #+BEGIN_SRC bash python3 example.py #+END_SRC Da Python schon eine etwas bekanntere Sprache ist, ist der Lernfaktor der Sprache selber nicht mehr so hoch. Allerdings gibt es noch viele interessante Konzepte, die man im Zusammenhang mit der Sprache lernen kann. Wie etwa zum Beispiel multiple Vererbung von Klassen. gls:borg selber wurde in Python geschrieben. Daher ist davon auszugehen das Python innerhalb dieser Community eine sehr hohe Verbreitung geniesst. Python ist eine dynamisch typisierte und interpretierte Sprache. Dies bedeutet das man bei Variablen nicht explizit den Typ angeben muss und die Programme zur Laufzeit für den Computer übersetzt werden. Interpretierte Sprachen haben den Vorteil das man mit ihnen in der Regel sehr schnell und unkompliziert entwickeln kann, dies jedoch zulasten der Performance. #+CAPTION: Python Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:python |--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- -ergebnis*\cellcolor[HTML]{C0C0C0} | |--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 8 | 8 | 80 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 5 | 25 | | 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 7 | 35 | | 6. Lesbarkeit des Codes | 5 | 5 | 4 | 20 | | 7. Einfachheit des Setups | 5 | 5 | 4 | 20 | | 8. Lernfaktor | 5 | 5 | 3 | 15 | | 9. Verbreitung in der BorgBackup Community | 5 | 5 | 5 | 25 | | 10. Geschwindigkeit der Entwicklung | 3 | 5 | 4 | 12 | |--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| | *Total* | | | | 322 | |--------------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+-------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4::@11$5=@11$2 * @11$4::@12$5=@12$2 * @12$4 #+TBLFM: @>$5=vsum(@3..@-1) *** Frontend Fürs Frontend sind folgende Projekte interessant: [[Qt][Qt]], [[Gtk][Gtk]] und [[Electron][Electron]]. Alle drei sind cross-plattform fähige gls:gui Frameworks und nicht von einer spezifischen Sprache abhängig. Da nahezu keine Erfahrung mit den aufgeführten Frameworks vorhanden ist, werden bei den Frontend Frameworks die Punkte der Verbreitung in der Community und Geschwindigkeit der Entwicklung ausgeschlossen. In beiden Fällen wäre nicht mal eine ungenaue Schätzung wirklich möglich. **** Qt Qt footcite:qt, "cute" ausgesprochen, ist ein Framework zum Entwickeln von grafischen Oberflächen, welche auf verschiedenen System ohne grosse Änderungen laufen sollen und sich dabei soweit als möglich wie eine native Applikation verhalten und "anfühlen" soll. Die Rechte an Qt hält die Firma "The Qt Company". Das Framework Qt wird jedoch offen entwickelt und die Community hat ein Mitspracherecht. Die Linux Desktopumgebung KDE nutzt das Qt Framework intensiv. Qt ist gls:libre und der gls:gpl v3 footcite:qtlicense oder mit einer kostenpflichtigen proprietären Lizenz erhältlich, falls die gls:gpl nicht genutzt werden kann. Vorkenntnisse zu Qt sind nur sehr wenig vorhanden. Mehr als ein paar Tests wurden damit noch nicht gemacht. Eine Qt Oberfläche kann direkt in der jeweiligen Sprache des Backends geschrieben werden oder Mittels des Qt Designers als XML Datei gespeichert und dann in die eigentliche Applikation importiert werden. Somit ist keine spezielle Software nötig. XML ist nicht übermässig gut lesbar, allerdings kann man Qt in der verwendeten Sprache programmiert werden somit ist es hauptsächlich von der Sprache im Backend abhängig. Die Dokumentation ist in C++ geschrieben was für einen Entwickler ohne C++ Kenntnisse die Software etwas unzugänglich macht. Qt scheint, soweit dies bis jetzt abgeschätzt werden kann, sehr leicht in ein Projekt zu integrieren sein. Da noch sehr wenig Kenntnisse vorhanden sind, ist der Lernfaktor entsprechend gross. #+CAPTION: Qt Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:qt |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 2 | 10 | | 4. Integriert sich gut ins System | 5 | 10 | 8 | 40 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 8 | 40 | | 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 | | 7. Einfachheit des Setups | 5 | 5 | 4 | 20 | | 8. Lernfaktor | 5 | 5 | 4 | 20 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | *Total* | | | | 295 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4 #+TBLFM: @>$5=vsum(@3..@-1) **** Gtk Gtk ist sowohl für Linux wie auch für Windows und OS X erhältlich. Gtk hat als Projekt der Gnome Foundation seine Wurzeln jedoch ganz klar in der Linux Welt. Gtk ist gls:libre unter der Lesser General Public Lizenz footcite:gtklicense. Gtk ist ein Projekt der GNOME Foundation einer nicht für Profit Organisation, welche die Entwicklung diverser freier Software Projekte koordiniert. Zu Gtk gibt es keinerlei Vorkenntnisse als Programmierer. Gtk wurde bis jetzt nur intensiv als User verwendet. Gtk integriert sich nur unter Linux wirklich gut ins System. Unter Windows und OS X können die Applikationen schnell etwas fremd wirken. Dies ist gut bei der Applikation Meld footcite:meld zu sehen, wenn man eine Datei auswählen möchte, Abbildung ([[fig:meld]]). #+caption: Screenshot der Applikation Meld unter Windows 10 #+name: fig:meld [[file:pictures/meld.png]] #+attr_latex: :center Die Gtk Dokumentation empfiehlt footcite:gtk_setup, dass man unter Windows das Programm MSYS2 installiert, um Gtk einzurichten. Zum Programmieren an sich braucht es offenbar nicht zwingend weitere Tools aus einem Editor. Wie auch bei Qt hat man jedoch die Möglichkeit das gls:gui mit einem gls:gui Designer grafisch zu erstellen. Wie auch Qt kann man Gtk entweder direkt in der Backend Sprache programmieren oder aus dem gls:gui Designer dann als XML exportieren. Der Code in der Dokumentation ist in C geschrieben, welches auch nicht die zugänglichste Sprache ist. Die Verwendung von Gtk innerhalb des Programms scheint ähnlich einfach zu sein wie bei Qt. Die Installation ist allerdings unter Windows eher das Gegenteil von einfach. Da die Kenntnisse gleich null sind, ist der Lernfaktor auf dem Maximum. #+CAPTION: Gtk Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:gtk |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 0 | 0 | | 4. Integriert sich gut ins System | 5 | 10 | 6 | 30 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 8 | 40 | | 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 | | 7. Einfachheit des Setups | 5 | 5 | 3 | 15 | | 8. Lernfaktor | 5 | 5 | 5 | 25 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | *Total* | | | | 275 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4 #+TBLFM: @>$5=vsum(@3..@-1) **** Electron Electron ist ein cross-plattform Framework zum Entwickeln von glspl:gui welches dabei jedoch auf Technologien aus der Webentwicklung benutzt. Entwickelt wird Electron von der Firma Github und ist gls:libre unter der MIT Lizenz footcite:electronlicense. Da Electron auf Technologien aus der Webentwicklung setzt, sind hier im Vergleich zu den anderen Frameworks bereit gute Kenntnisse vorhanden. Über die genau Funktion und Implementierung sind noch keine Kenntnisse vorhanden. Die Verwendung von Webtechnologien macht Electron zwar sehr kompatibel auf den unterstützten Systemen, oftmals sehen die Applikationen jedoch doch eher wie eine Webseite als wie eine Desktop Applikation aus. Ein weiterer Nachteil ist der hohe Ressourcenverbrauch, da jede Applikation nahezu einer eigenen Instanz des Google Chrome Browsers gleich kommt. Bei der Installation muss Node.js und der Paket Manager von Node.js, NPM, vorhanden sein. Zum Programmieren selber braucht es keine speziellen Tools. Ein Editor und ein Webbrowser sollten ausreichend sein. Electron Applikationen bestehen hauptsächlich aus HTML, CSS und JavaScript Code. Wenn man sich die komplette Applikation in Node.js programmieren möchte kommt dann noch eine zusätzliche Sprache hinzu. HTML ist ähnlich mühsam zu lesen wie XML. CSS und JavaScript sind relativ angenehm zu lesen, wobei es für beide keine offiziellen Styleguides gibt. Was bei Webanwendungen jedoch immer das schwierigste ist, ist der Wechsel zwischen verschiedenen Sprachen und Konzepten. Dieses Problem hat man bei Electron leider auch. Das Setup von Electron ist etwa ähnlich kompliziert wie das Setup von Gtk und ist sehr ähnlich dem Entwickeln einer normalen Webapplikation. Da an der IBZ Webtechnologien bereits intensiv behandelt worden sind und man in diesem Rahmen bereits ein paar Webapplikationen erstellt hat, wäre der Lernfaktor bei Electron wohl nicht so gross wie etwa bei Qt oder Gtk. #+CAPTION: Electron Bewertungstabelle #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4cm}|c|p{2cm}|p{2cm}|p{2cm}| #+NAME: tab:electron |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | <20> | <20> | <20> | <20> | <20> | | *Kriterium*\cellcolor[HTML]{C0C0C0} | *Gewichtung*\cellcolor[HTML]{C0C0C0} | *max. Punktzahl*\cellcolor[HTML]{C0C0C0} | *erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | *Kriteriums- ergebnis*\cellcolor[HTML]{C0C0C0} | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | 1. Cross Plattform nutzbar | 10 | 10 | 10 | 100 | | 2. Freie Software | 5 | 10 | 10 | 50 | | 3. Vorkenntnisse | 5 | 10 | 5 | 25 | | 4. Integriert sich gut ins System | 5 | 10 | 4 | 20 | | 5. Ohne spezielle Tools nutzbar | 5 | 10 | 7 | 35 | | 6. Lesbarkeit des Codes | 5 | 5 | 3 | 15 | | 7. Einfachheit des Setups | 5 | 5 | 3 | 15 | | 8. Lernfaktor | 5 | 5 | 3 | 15 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| | *Total* | | | | 275 | |-------------------------------------+--------------------------------------+------------------------------------------+-----------------------------------------------+------------------------------------------------| #+TBLFM: @3$5=@3$2 * @3$4::@4$5=@4$2 * @4$4::@5$5=@5$2 * @5$4::@6$5=@6$2 * @6$4::@7$5=@7$2 * @7$4::@8$5=@8$2 * @8$4::@9$5=@9$2 * @9$4::@10$5=@10$2 * @10$4 #+TBLFM: @>$5=vsum(@3..@-1) *** Ergebnis Aufgrund der erreichten Punktzahl, Tabelle:([[tab:result]]), bei den vorhergehenden Variantenbewertungen, wurde entschieden für das Backend der Applikation auf Python zu setzen und fürs Frontend Qt zu benutzen. #+CAPTION: Variantenbewertung Ergebnis #+ATTR_LATEX: :align |>{\columncolor[HTML]{EFEFEF}}p{4.5cm}|r| :placement [H] #+NAME: tab:result |------------------------------------+-----------------------------------------------| | *Variante*\cellcolor[HTML]{C0C0C0} | *Erreichte Punktzahl*\cellcolor[HTML]{C0C0C0} | |------------------------------------+-----------------------------------------------| | *Backend* | | | C# | 279 | | C++ | 271 | | Python | 322 | | *Frontend* | | | Qt | 295 | | Gtk | 275 | | Electron | 275 | |------------------------------------+-----------------------------------------------| ** Applikationsname Da die einzusetzende Technologie nun feststeht lässt sich auch gut ein Name für die Applikation ableiten. Oftmals werden die grafischen Applikationen gleich benannt wie die Kommandozeilen Applikation aber mit dem Namen des gls:gui Frameworks als Suffix. Somit wird das zu erstellende gls:gui für gls:borg im weiteren Verlauf der Arbeit nun Borg-Qt genannt ** Testing Die Anwendung wird während der Realisierung soweit als möglich mit automatischen Unittests und Funktionstests überprüft. Dies hauptsächlich um die Erfahrung in diesem Bereich zu erweitern und um ein gutes Fundament für die Zukunft des Projektes zu bauen. Aufgrund der Unerfahrenheit in diesem Bereich werden die Testfälle, Tabelle:([[tab:testcases]]), final jedoch von Hand überprüft. Somit kann vermieden werden das nicht funktionierende automatische Tests den Abschluss des Projektes verhindern. Da die Testfälle sich hauptsächlich an den Use Cases orientieren gibt es ein paar Ziele die dadurch nicht getestet werden können. Zudem sind zur Zeit nur ca. 20. der Ziele durch die Use Cases abgedeckt. Die weiteren Ziele lassen sich erst sinnvoll integrieren wenn die Basis für das Programm geschaffen wurde. Die Ziele die nicht durch die Testfälle getestet werden können sind Ziel Nr. 1 und Nr. 2. Für Ziel Nr. 1 wird in der Sektion [[Realisierung]] ein Proof of Concept erstellt um die cross-plattform Fähigkeit zu beweisen. Ziel Nr. 2 ist mit folgendem Link erfüllt. https://github.com/borg-qt/borg-qt/blob/master/LICENSE. Dabei handelt es sich um die Lizenz des Borg-Qt Repository. Getestet wird die Applikation jeweils auf dem Computer des Projektleiters. Auf diesem läuft die aktuelle Langzeitsupport Version (18.04) von Ubuntu footcite:ubuntu Linux, mit der GNOME Desktop Umgebung footcite:gnome, als Betriebssystem. Die Tests werden jeweils gegen eine von PyInstaller generierte Binärdatei ausgeführt. Der genaue Vorgang der Erstellung dieser Datei wird in der Sektion: [[Releases][Releases]] beschrieben. Somit werden die Tests immer gegen eine veröffentlichbare Version gemacht. Als Testdateien wird jeweils das Code Repository von Borg-Qt selber verwendet. Der Pfad des gls:borg Repository für lokale Backups soll ~/tmp/test-borgqt~ sein, in den Testfällen "Lokales Repository", genannt und das Passwort ~foo~. Im Makefile des Repository wird dieses Setup definiert. Somit kann man als Entwickler nur ~make repo~ ausführen und hat eine funktionsfähige Testumgebung. Um Backups über SSH testen zu können wird eine virtuelle Maschine mit Ubuntu 18.04 verwendet. Die Konfiguration der virtuellen Maschine sieht dabei wie folgt aus: - 2 CPU Kerne - 1024 MB RAM - IP: 10.7.89.117 - Ein User ~borg~ mit Passwort ~borg~ - gls:borg Repository unter ~/home/borg/backup/diplom~ mit Passwort ~foo~, in den Testfällen "Server Repository" genannt - Der SSH Key des Entwicklers wird in den User ~borg~ importiert. Dies ermöglicht Passwort freie Logins. #+LATEX:\newpage #+LATEX:\begin{landscape} ** Testfälle #+LATEX:{\footnotesize #+CAPTION: Testfälle #+ATTR_LATEX: :environment longtable :align |>{\columncolor[HTML]{EFEFEF}}l|p{2cm}|p{2cm}|p{3.5cm}|p{2cm}|p{3cm}|p{3.5cm}|p{2.5cm}| :placement [H] #+NAME: tab:testcases |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | <20> | <10> | <10> | <10> | <10> | <10> | <10> | <10> | | *ID*\cellcolor[HTML]{C0C0C0} | *Objective*\cellcolor[HTML]{C0C0C0} | *Precondition*\cellcolor[HTML]{C0C0C0} | *Steps*\cellcolor[HTML]{C0C0C0} | *Testdata*\cellcolor[HTML]{C0C0C0} | *Expected Result*\cellcolor[HTML]{C0C0C0} | *Postcondition*\cellcolor[HTML]{C0C0C0} | *Result*\cellcolor[HTML]{C0C0C0} | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-01* | Anwendung starten | Lokales Repository initialisiert.\newline Lokale Konfigurationsdatei erstellt. | 1. Anwendung starten. | - | Die Anwendung startet ohne Fehlermeldung und zeigt eine leere Backup Liste an. | Die Anwendung wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-02* | Anwendung starten | Lokale Konfigurationsdatei erstellt. | 1. Anwendung starten. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-03* | Anwendung starten | - | 1. Anwendung starten. | - | Die wirft eine Fehlermeldung das sie die Konfigurationsdatei nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-04* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup an. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-05* | Lokales Backup erstellen | TC-01 ausgeführt.\newline BorgBackup macht bereits ein Backup. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung das BorgBackup bereits ausgeführt wird. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-06* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Ordnerübersicht das Code Repository auswählen.\newline 3. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-07* | Lokales Backup erstellen | TC-01 ausgeführt. | 1. Den Button “Backup” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User einen Pfad angeben soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-08* | Lokales Backup löschen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Delete” betätigen. | - | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Löschen verschwindet. | Die Backup Liste wird aktualisiert und ist nun leer. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-09* | Lokales Backup löschen | TC-04 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Delete” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-10* | Lokales Backup löschen | TC-04 ausgeführt. | 1. Den Button “Delete” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User ein Backup auswählen soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-11* | Lokales Backup wiederherstellen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Restore” betätigen.\newline 3. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 4. Den Button “Open” anklicken. | - | Nach erfolgtem Wiederherstellen öffnet ein Dateiexplorer den Ziel Pfad. | Die Anwendung und ein Dateiexplorer wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-12* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. Den Button “Backup” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das der User ein Backup auswählen soll. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-13* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Restore” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-14* | Lokales Backup wiederherstellen | TC-01 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Restore” betätigen.\newline 3. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 4. Den Button “Cancel” anklicken. | - | Der Datei Dialog schliesst sich wieder. | Die Anwendung wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-15* | Home Directory sichern und wiederherstellen | TC-01 ausgeführt. | 1. Vom Pfad "/home/andreas/" ein Backup erstellen.\newline 2. In der Backup Liste das gemachte Backup auswählen.\newline 3. Den Button “Restore” betätigen.\newline 4. Im geöffneten Dateidialog den Pfad "/home/andreas/Downloads" auswählen.\newline 5. Den Button “Open” anklicken. | "/home/andreas/" | Nach erfolgtem Wiederherstellen öffnet ein Dateiexplorer den Ziel Pfad.\newline Darin fehlen jedoch temporäre Pfade wie “~/.cache” etc. | Die Anwendung und ein Dateiexplorer wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-16* | Einzelne Datei wiederherstellen | TC-04 ausgeführt. | 1. In der Backup Liste das Backup auswählen.\newline 2. Den Button “Mount” betätigen.\newline 3. Aus dem sich öffnenden Dateiexplorer die Datei README.org nach "/home/andreas/Downloads" kopieren. | - | Die wiederhergestellte Datei ist identisch mit der in TC-04 gesicherten. | Die Anwendung und ein Dateiexplorer wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-17* | Einzelne Datei wiederherstellen | TC-01 ausgeführt. | 1. Das Lokale Repository an einen beliebigen Ort verschieben.\newline 2. In der Backup Liste das Backup auswählen.\newline 3. Den Button “Mount” betätigen. | - | Die Anwendung wirft eine Fehlermeldung das sie das lokale Repository nicht finden kann. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-18* | Pfad des lokalen Backup Repository anpassen | TC-04 ausgeführt.\newline Backup Repository nach "/tmp/test-borgqt2" verschoben | 1. Den Button "Settings" betätigen.\newline 2. Den Repository Pfad auf "/tmp/test-borgqt2/" ändern.\newline 3. Den Button "Apply" betätigen. | - | Die Backup Liste wird aktualisiert und zeigt wieder das Backup von TC-04 an. | Die Anwendung wird angezeigt. Die Konfigurationsdatei zeigt auf den neuen Pfad. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-19* | Backup Name ändern | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Bei der Option "Archive Prefix" "Muster" eintragen.\newline 3. Den Button "Apply" betätigen.\newline 4. TC-04 durchführen. | Backupname: Muster | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup mit dem Präfix "Muster" an. Die Konfigurationsdatei beinhaltet die Option des Präfixes. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-20* | Keine Einstellungen ändern | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Eine beliebige Option ändern.\newline 3. Den Button "Cancel" betätigen. | - | Der Einstellungsdialog schliesst sich. | Die Anwendung wird angezeigt. Die Konfigurationsdatei ist noch im selben Zustand wie bei TC-01. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-21* | Automatische Backups konfigurieren | TC-01 ausgeführt. | 1. Den Button "Settings" betätigen.\newline 2. Bei der Option "Automatic Backups" bei "Backup Path" die Testdateien angeben sowie "Hourly" auswählen und bei "Time" die nächste Stunde angeben.\newline 3. Den Button Apply betätigen. | Backup-zeit: 2 Minuten nach aktueller Zeit Testdateien | Der Datei Dialog schliesst sich wieder. | Die Anwendung wird angezeigt. Die Konfigurationsdatei wurde um die Option des automatischen Backups erweitert. Die Anwendung hat einen "Service" auf dem System erstellt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-22* | Automatische Backups durchführen | TC-16 ausgeführt. | 1. TC-21 durchführen.\newline 2. Auf Ablauf der Zeit warten.\newline 3. Die Anwendung öffnen. | - | In der Backup Liste wird ein Backup angezeigt. | Die Anwendung wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-23* | Server Backup erstellen | Server Repository bereit.\newline Server Konfigurationsdatei erstellt. | TC-04 durchführen. | Testdateien | Die Anwendung zeigt einen Fortschrittsbalken der nach erfolgtem Backup verschwindet. | Die Backup Liste wird aktualisiert und zeigt ein Backup an. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-24* | Lokales Backup erstellen während dem eine VM läuft | TC-01 ausgeführt.\newline Virtualbox VM Starten. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen. | Testdateien | Die Anwendung wirft eine Fehlermeldung aus das es zur Zeit aufgrund einer laufenden VM unsicher sei ein Backup durchzuführen. | Die geöffnete Fehlermeldung blockiert die Applikation. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| | *TC-25* | Abgebrochenes Backup bereinigen | TC-01 ausgeführt. | 1. In der Ordnerübersicht das Code Repository auswählen.\newline 2. Den Button “Backup” betätigen.\newline 3. Die Anwendung schliessen.\newline 4. Anwendung wieder öffnen.\newline 5. TC-04 Durchführen. | Testdateien | Bei Schritt 4. sollte ein Teilbackup zu sehen sein.\newline Bei Schritt 5 sollte einfach ein normales Backup zu sehen sein. | Die Anwendung wird angezeigt. | | |------------------------------+----------------------------------------------------+---------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+--------------------------------------------------------+-----------------------------------------------------------------------------------------------------------------------------------------+---------------------------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------| #+LATEX:} #+LATEX:\end{landscape} #+LATEX:\newpage * TODO Realisierung ** Cross-plattform Kompatibilität Um sicherzugehen das die gewählten Technologien auch den Anforderungen entsprechen wurde ein kleines "Hello World" Programm mit Python3 und Qt geschrieben. Dieses läuft ohne jegliche Probleme und Anpassung auf Windows, Linux und OS X. Wie in den Screenshots in Abbildung:([[fig:hello_world]]) zu sehen ist. #+caption: Python und Qt Applikation unter Windows (links), Linux (rechts) und OS X (unten) #+name: fig:hello_world [[file:pictures/hello_world.png]] #+attr_latex: :center ** TODO Benutzerinterface *** Inspiration Bevor gls:borg vom Projektleiter als Backup Software eingesetzt wurde, nutzte er die Software "Back in Time"footcite:backintime. Die Software setzt auf Rsync zum kopieren der Dateien. Dies erlaubt auch schnelle Backups über SSH zu machen. "Back in Time" hat allerdings das Problem, dass es keine gls:dedup beherrscht. Das Userinterface, zu sehen in Abbildung:([[fig:bit_main]]), ist jedoch sehr gelungen und soll Borg-Qt als Vorlage dienen. Insbesondere die einfache und direkte Art ein Backup eines spezifischen Pfades zu machen ist sehr spannend. Da sie es dem User so einfach wie möglich macht ein Backup zu erstellen. #+caption: Screenshot des Hauptfensters der Software "Back in Time" #+name: fig:bit_main [[file:pictures/bit_main.png]] #+attr_latex: :center *** TODO Umsetzung Qt bietet einem mehrere Möglichkeiten zum erstellen der graphischen Oberfläche. Zum einen kann die ganze Oberfläche programmatisch erstellt werden. Dies gibt dem ein grosses Mass an Kontrolle über das Erstellte ist allerdings nicht sehr intuitiv. Die angenehmere Variante ist des den Qt Designer, Abbildung:([[fig:qt_designer]]), zu nutzen. Mit diesem lassen sich die Oberflächen in einer graphischen Oberfläche designen und mit einem Befehl auch gleich starten damit man direkt sieht wie sich die Oberflächen auf dem System verhalten. #+caption: Ein Screenshot der Applikation Qt Designer #+name: fig:qt_designer [[file:pictures/qt_designer.png]] #+attr_latex: :center Auf Basis der Ziele und der Use Cases wurde eine erste Version des glspl:gui erstellt. Im Hauptfenster, Abbildung:([[fig:borgqt_main_v1]]), befinden sich wie auch bei "Back in Time" in der einen Hälfte eine Liste der vorhandenen Backups (bei Borg Archive genannt) und in der anderen Hälfte ein Dateimanagemer. Dieser dient zur Auswahl des zu sichernden Pfades. Im oberen Bereich findet sich die Toolbar mit den Aktionen die der User ausführen kann. Gemäss den Use Cases sind dies "Backup", "Restore", "Mount", "Delete" und "Settings". #+caption: Screenshot des Borg-Qt Hauptfensters Version 1 #+name: fig:borgqt_main_v1 #+attr_latex: :placement [H] [[file:pictures/borgqt_main_v1.png]] Im Einstellungsfenster gibt es zwei Tabs zur Auswahl. Einmal den "General" Tab, Abbildung:([[fig:borgqt_settings_general_v1]]), dieser zeigt allgemeine Optionen an. Der zweite Tab "Exlcude", Abbildung:([[fig:borgqt_settings_exclude_v1]]), gibt dem User die Möglichkeit einzelne Ordner oder Dateien von den Backups auszuschliessen. #+caption: Screenshot der Borg-Qt "General" Einstellungen Version 1 #+name: fig:borgqt_settings_general_v1 #+attr_latex: :width .7\textwidth :placement [H] [[file:pictures/borgqt_settings_general_v1.png]] #+caption: Screenshot der Borg-Qt "Exclude" Einstellungen Version 1 #+name: fig:borgqt_settings_exclude_v1 #+attr_latex: :width .7\textwidth :placement [H] [[file:pictures/borgqt_settings_exclude_v1.png]] Das "Progress" Dialogfenster, Abbildung:([[fig:borgqt_progress_v1]]), zeigt dem User einen Fortschrittsbalken und einen einen "Cancel" Button zum Abbrechen der Aktion an. Das Fenster ist generisch gehalten damit es von verschiedenen Tasks gleichermassen genutzt werden kann. #+caption: Screenshot des Borg-Qt "Progress" Dialogfensters Version 1 #+name: fig:borgqt_progress_v1 #+attr_latex: :width .6\textwidth :placement [H] [[file:pictures/borgqt_progress_v1.png]] Im "Archive" Dialogfenster, Abbildung:([[fig:borgqt_archiv_v1]]), werden Detailinformationen eines Archives angezeigt. Diese sind etwa die Grösse des Archives, wieviele Dateien es beinhaltet, wie lange das Erstellen dauerte, etc. #+caption: Screenshot des Borg-Qt Archivinformationsfenster Version 1 #+name: fig:borgqt_archiv_v1 #+attr_latex: :width .6\textwidth :placement [H] [[file:pictures/borgqt_archive_v1.png]] ** TODO Backend Umsetzung PLACEHOLDER ** TODO Releases * TODO Ausblick ** TODO Projektmanagement PLACEHOLDER ** TODO Umsetzung PLACEHOLDER ** TODO Gelerntes PLACEHOLDER #+LATEX:\newpage #+LATEX:\begin{landscape} * Arbeitsjournal #+CAPTION: Arbeitsjournal #+ATTR_LATEX: :environment longtable :align |p{2cm}|p{5cm}|p{5cm}|p{7cm}| #+NAME: tab:arbeitsjournal |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| | *Datum*\cellcolor[HTML]{C0C0C0} | *Geplante Arbeiten*\cellcolor[HTML]{C0C0C0} | *Erreichte Arbeiten*\cellcolor[HTML]{C0C0C0} | *Eindruck*\cellcolor[HTML]{C0C0C0} | | <8> | <20> | <20> | <20> | |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| | 16.12.2018 | Zeitplan erarbeiten, Ziele dokumentieren | keine Abweichung | - | |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| | 23.12.2018 | Lösungsvarianten erfassen, Lösungsvarianten bewerten, Lösungsvariante bestimmen, SWOT Analyse erstellen, 1. Meeting | keine Abweichung | Marco Frei hat noch diverse Punkte eingebracht die, die Planung ziemlich durcheinander bringen. Bedeute viel zusätzliche Arbeit. | |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| | 30.12.2018 | Controlling erarbeiten, Ist- und Soll-Analyse, SWOT Analyse, Umweltanalyse, Massnahmen Katalog erarbeiten, User Stories erarbeiten, Use Case Diagramm erstellen, Use Cases ausarbeiten, Anforderungskatalog erstellen, UML Diagramme | keine Abweichung | UML Diagramme für eine Software zu erstellen die nicht existiert ist noch eine interessante Herausforderung. | |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| | 06.01.2019 | Lösungsvarianten erarbeiten und entscheiden, Test Konzept beschreiben und Testfälle erstellen, Github Repository erstellen | Testfälle liessen sich noch nicht für alle Ziele erstellen. Gewisse Features hängen noch sehr davon ab wie die Basis der Applikation sich entwickelt. | | |---------------------------------+--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+-------------------------------------------------------------------------------------------------------------------------------------------------------+----------------------------------------------------------------------------------------------------------------------------------| #+LATEX:\end{landscape} * Bibliography :no_export: bibliography:general/bibliography.bib