Entwickler: Unterschied zwischen den Versionen

Aus OrgaMon Wiki
Zur Navigation springen Zur Suche springen
 
(12 dazwischenliegende Versionen desselben Benutzers werden nicht angezeigt)
Zeile 4: Zeile 4:
<i>Freie Software ist die Basis für IT-Sicherheit</i><br>
<i>Freie Software ist die Basis für IT-Sicherheit</i><br>
[Richard Stallman]
[Richard Stallman]
* Aktuelle Entwicklungen: https://github.com/Andreas-Filsinger/OrgaMon/commits/main/


== OrgaMon, unterstützte Betriebssysteme ==
== OrgaMon, unterstützte Betriebssysteme ==
Zeile 9: Zeile 11:
* Win32, Windows 2000, XP, Vista, Windows 7, Windows 10
* Win32, Windows 2000, XP, Vista, Windows 7, Windows 10
* Linux über die Emulations-Schicht Wine ab 0.98.5
* Linux über die Emulations-Schicht Wine ab 0.98.5
* Virtualisierte Windows XP Systeme (via VirtualBox)
* Virtualisierte Windows 10 Systeme (via [[Linux.kvm]])


== OrgaMon-App, unterstützte Betriebssysteme ==
== OrgaMon-App, unterstützte Betriebssysteme ==
Zeile 41: Zeile 43:


*[[OrgaMon-RC]]
*[[OrgaMon-RC]]
== OrgaMon-Server-Identitäten ==
* der OrgaMon-Quelltext für die Konsolen-Anwendung (win32/linux) ist so universell gehalten, dass auch der Quelltext mit dem FreePascal [http://freepascal.org]-Compiler übersetzt werden kann (ab Rev. 8.000).
* Stand 2016: Im Moment läuft bei der Freepascal Compilierung nur das Target Win32. In Zukunft wird ein "lOrgaMon" als Serverprozess für Linux erwartet. Dazu muss ich noch automatisierte Tests in win32 vorbereiten, die dann identisch unter Linux ablaufen müssen.
=== cOrgaMon ===
cOrgaMOn.exe ist eine monolitische Anwendung die per Kommandozeilenparameter verschiedene Identitäten annehmen kann. Für jede Identität muss dann eine eigene Instanz des Prozesses gestartet werden.
==== id_TWebShop ====
* der XMLRPC für den TWebShop
==== id_Bestellen ====
==== id_Mail ====
==== id_Druck ====
==== id_App ====
* der Service für "senden" der OrgaMon-App
ftphost=
ftpuser=
ftppwd=
port=
LogPath=
# default = "NEIN"
NoTimeCheck=["JA"|"NEIN"]
==== id_Foto ====
[[cOrgaMon.Foto]]
=== lOrgaMon ===
der XMLRPC für den OrgaMon (Linux-Konsolenanwendung,Win32-Konsolenanwendung)
<code>
0x0000000000000000  0x43e7000  C:\Program Files\OrgaMon\lOrgaMon.exe
<s>0x000000004aad0000  0x1f8000  C:\WINDOWS\SYSTEM32\ntdll.dll</s>
<s>0x0000000049c80000  0xbf000  C:\WINDOWS\System32\KERNEL32.DLL</s>
<s>0x00000000481b0000  0x2f6000  C:\WINDOWS\System32\KERNELBASE.dll</s>
<s>0x000000004a9c0000  0xcd000  C:\WINDOWS\System32\oleaut32.dll</s>
<s>0x00000000488b0000  0x9d000  C:\WINDOWS\System32\msvcp_win.dll</s>
<s>0x0000000048550000  0x100000  C:\WINDOWS\System32\ucrtbase.dll</s>
<s>0x0000000048dd0000  0x354000  C:\WINDOWS\System32\combase.dll</s>
<s>0x0000000049230000  0x126000  C:\WINDOWS\System32\RPCRT4.dll</s>
<s>0x00000000498f0000  0x19d000  C:\WINDOWS\System32\user32.dll</s>
<s>0x0000000048ab0000  0x22000  C:\WINDOWS\System32\win32u.dll</s>
<s>0x0000000049b50000  0x2c000  C:\WINDOWS\System32\GDI32.dll</s>
<s>0x0000000048650000  0x115000  C:\WINDOWS\System32\gdi32full.dll</s>
0x000000004a790000  0xaf000  C:\WINDOWS\System32\advapi32.dll
<s>0x0000000048d00000  0x9e000  C:\WINDOWS\System32\msvcrt.dll</s>
0x0000000049190000  0x9c000  C:\WINDOWS\System32\sechost.dll
0x0000000049f10000  0x744000  C:\WINDOWS\System32\shell32.dll
0x000000004a660000  0x12a000  C:\WINDOWS\System32\ole32.dll
0x0000000043690000  0xa000    C:\WINDOWS\SYSTEM32\version.dll
0x0000000037bd0000  0xb0000  C:\WINDOWS\WinSxS\amd64_microsoft.windows.common-controls_6595b64144ccf1df_5.82.19041.1110_none_792d1c772443f647\comctl32.dll
0x0000000080000000  0x12d000  C:\Program Files\OrgaMon\tgputtylib.dll
<s>0x0000000048da0000  0x30000  C:\WINDOWS\System32\IMM32.DLL</s>
<s>0x0000000045bc0000  0x9e000  C:\WINDOWS\system32\uxtheme.dll</s>
0x000000002c140000  0x7000    C:\WINDOWS\SYSTEM32\msimg32.dll
0x00000000001b0000  0x3000    C:\WINDOWS\SYSTEM32\security.dll
0x0000000043140000  0xc000    C:\WINDOWS\SYSTEM32\SECUR32.DLL
0x0000000048070000  0x32000  C:\WINDOWS\SYSTEM32\SSPICLI.DLL
0x0000000046290000  0x793000  C:\WINDOWS\SYSTEM32\windows.storage.dll
0x0000000047ba0000  0x2e000  C:\WINDOWS\SYSTEM32\Wldp.dll
0x0000000048b30000  0xad000  C:\WINDOWS\System32\SHCORE.dll
0x0000000049130000  0x55000  C:\WINDOWS\System32\shlwapi.dll
0x0000000046090000  0x12000  C:\WINDOWS\SYSTEM32\kernel.appcore.dll
0x0000000048770000  0x82000  C:\WINDOWS\System32\bcryptPrimitives.dll
0x0000000049360000  0xa9000  C:\WINDOWS\System32\clbcatq.dll
0x0000000045620000  0xf6000  C:\WINDOWS\SYSTEM32\PROPSYS.dll
0x0000000010000000  0xdd000  C:\WINDOWS\SYSTEM32\fbclient.dll
0x0000000049410000  0x6b000  C:\WINDOWS\System32\WS2_32.dll
0x0000000037dd0000  0x1d000  C:\WINDOWS\SYSTEM32\MPR.dll
0x00000000624a0000  0xc9000  C:\WINDOWS\WinSxS\amd64_microsoft.vc80.crt_1fc8b3b9a1e18e3b_8.0.50727.9672_none_88e266cb2fac7c0d\MSVCR80.dll
0x0000000035200000  0x17000  C:\WINDOWS\system32\napinsp.dll
0x0000000035130000  0x1b000  C:\WINDOWS\system32\pnrpnsp.dll
0x0000000035110000  0x15000  C:\WINDOWS\system32\wshbth.dll
0x0000000043bc0000  0x1d000  C:\WINDOWS\system32\NLAapi.dll
0x0000000047580000  0x3c000  C:\WINDOWS\SYSTEM32\IPHLPAPI.DLL
0x0000000047890000  0x6a000  C:\WINDOWS\System32\mswsock.dll
0x00000000475c0000  0xcb000  C:\WINDOWS\SYSTEM32\DNSAPI.dll
0x0000000049b90000  0x8000    C:\WINDOWS\System32\NSI.dll
0x00000000350f0000  0x12000  C:\WINDOWS\System32\winrnr.dll
0x000000003eea0000  0x82000  C:\WINDOWS\System32\fwpuclnt.dll
0x0000000048520000  0x27000  C:\WINDOWS\System32\bcrypt.dll
0x000000003f320000  0xa000    C:\Windows\System32\rasadhlp.dll
0x0000000047800000  0x8b000  C:\WINDOWS\system32\msv1_0.DLL
0x00000000477e0000  0x14000  C:\WINDOWS\SYSTEM32\NtlmShared.dll
0x0000000047900000  0x15000  C:\WINDOWS\SYSTEM32\cryptdll.dll
0x0000000028000000  0x7000    C:\WINDOWS\SYSTEM32\IdnDL.dll
0x0000000049b80000  0x8000    C:\WINDOWS\System32\Normaliz.dll
</code>
== OrgaMon-Appliance ==
=== Begriffsdefinition ===
* '''OrgaMon-Appliance''' ist Gesamtheit der WAN-Mandant Infrastruktur
* '''Mandant''' ist die Datensumme aus Datenbank-Inhalt und Dateisysteminhalt
** '''lokaler Mandant''' OrgaMon + lokales Dateisystem + embedded firebird (Einzelplatz)
** '''LAN Mandant''' OrgaMon + Verzeichnis im NAS + firebird Server
** '''WAN Mandant''' OrgaMon + Sync auf das NAS + OrgaMon-Ghost
* '''Client''' ist ein vollständiger (mit GUI) laufender OrgaMon.exe
* '''Ghost''' ist ein cOrgaMon.exe ohne GUI
* '''Schrittzähler''' Jede echte Veränderung am Mandant hat ein inkrementieren des Schrittzählers zur Folge. Veränderte Objekte erhalten als Stempel diesen Schrittzählerwert eingestempelt. Reines Lesen oder Schreiben ohne Änderung erhöhen den Schrittzähler nicht.
=== Vorteile ===
die OrgaMon-Appliance ermöglich das Arbeiten mit einem WAN - Mandanten. Dabei wird lokal die OrgaMon-Anwendung verwendet. Über das Internet wird Kontakt zu einer OrgaMon-Appliance hergestellt. Die Datenbank und das Dateisystem liegt dabei in der Appliance.
Die Dienste eMail, Tagwache, Tagesabschluss, FTP-Bereich, liegen dabei auf dem Appliance-Host.
Die Datenbank-Operationen werden 100% auf einem Server durchgeführt, die Dateioperationen müssen teilweise per "save" and "send" (Lokales speichern auf dem Server UND senden an den Client) oder "save" und "replicate" (lokales speichern und replizieren wenn es die Bandbreite zu lässt).
=== Kopplung "Applikationsservers" und "Client" ===
der Client ist immer grundsätzlich funktional vollständig, das bedeutet er "könnte" auch alle Funktionen lokal mit einer eigenen Datenbank und auf dem eigenen Dateisystem ausführen. Intern im OrgaMon sind je nach Mandant (lokal oder Remote) die Ausführungswege jedoch anders gesteuert.
Bei einem WAN-Mandanten deligiert der Client die Aufgaben an den Server. Dazu erzeugt der Client eine Anforderung als kleines Pascal-Script und sendet es zur Ausführung dem Server.
Im Rahmen der Ausführung kann nun auch der Server seinerseits Rückfragen (inquire) oder Feedback senden. Dies erfolgt analog ebenso in Form eines Pascal-Scripts.
==== Mögliche Implementierung ====
* https://www.suse.com/products/susestudio/
* http://www.openstack.org/
=== OrgaMon Ghosts ===
(1:1 instanzierung des Applikationsserver)
Mit einem OrgaMon-Client kann man auch eine extra gestartete Ghost Instanz (1:1 Beziehung) des OrgaMon über eine TCP/IP Verbindung konnektieren. Ein Dispatcher hilft dabei bei der Konnektierung zwischen Client und Ghost, ev. auch mal bei einem Re-Connect.
Buisiness-Logik Funktionen werden auf dem Migrationsweg zunehmend über "Interfaceable" Datenmodule abgewickelt. Im OrgaMon müssen nun Datenmodule entweder ...
* lokal konnektieren, dann läuft die Funktion über die lokale CPU ab, sie operiert dabei mit der angegebenen Datenbank und dem angegebenen Dateisystem.
* remote konnektieren, die Funktionsaufrufe werden sequenzialisiert und zum remote übertragen. Dieser führt den Code unter veränderung der dortigen Datenbank und des dortigen Dateisystems aus. Der Rückgabewert wird wiederum über TCP versendet.
==== File Sync ====
Es ist möglich dass im Rahmen der Codeausführung auf dem Server Dateien im lokalen Dateisystem des Servers auf den Client synchronisiert werden müssen. Der Server Code muss diese Dateinamen einem SynDienst melden: Dieser wird sofort eine Synchronisation durchführen. Entsprechende Anfragen muss die entsprechende Routine dem Interface mitteilen, da VOR Zurückkehren der Routine auch das Dateisystem sychronisiert sein muss! (Es sei denn auf dem Client gibt es eine ensure(FName) Funktion die Signalisiert, dass diese datei JETZT wieder gebraucht wird, ensure würde in diesem Fall warten bis die Datei da ist!) Ansonsten kann diese Aktion asynchron ablaufen.
Entstehen nun auf dem Remote neue Dateien, so wir als Funktionsergebnis das initiieren eines FTP Downloades gefordert, der Client holt sich also die Ergebnisse über FTP ab, und spiegelt sie auf der lokalen Platte nun wieder.
==== break ====
der Server hat zu jeder Zeit die Möglichkeit eine Aktion abzubrechen. Dies sieht technisch nicht anders aus, als eine normale vollständige Ausführung. Der Client muss aber auch die Möglichkeit haben einen "Break" zur aktuellen Aktion zu senden.
während der Laufzeit muss eigentlich das Interface nahtlos austauschbar sein.
=== lokale Aktionen ===
weiterhin gibt es völlig lokal ausführbare Operationen. Beispiele:
* "Was ist neu"
* "TPicUpload"
* Öffnen der Dokumentverzeichnisse einer Person
* Eingaben (es wird gelb) bis der Haken gedrückt wird
=== Caching ===
Die kommunizierenden Systeme (OrgaMon + OrgaMon Ghost) haben ein umfassendes Verständnis von Caching. Caching bedeutet, dass Antworten auf gewisse Fragen vom Client lokal gespeichert werden dürfen. Antworten können dabei ganze Tabellen sein, die einen beachtlichen Datenumfang haben. Ein Cache-Hit kann also umfassende Latenzvorteile bringen.
Anworten werden vom Server mit einer eTag versehen. Wie bereits an anderer Stelle angedeutet spielt hier der eTag eine ganz besondere Rolle. Der Client stellt unwissend eine Frage (das eTag ist dabei noch "null") er bekommt die Antwort UND einen dazu passenden eTag.
Das nächste Mal wenn er die völlig identische Frage nochmals stellt, sendet er nur den eTag im Header. Nun ist es am Server zu sagen "unchanged" oder einen neuen eTag und den neuen Content zu senden.
Da Datenbankabfragen mit teilweise sehr grossen Antworten "select * from" einhergehen in Verbindungs damit dass ofmals ein "Refresh" notwendig ist. Ist das Caching von Datenbank-Werten erlaubt und wird durch eine besondere Technik unterstützt.
Client->Server: SQL-Anfrage
Server->Client: eTag & Antwort-Paket
später
Client->Server: eTag?
Server: Unchanged alternativ neuer eTag + Content
=== Asynchrones Arbeiten ===
Wichtige Fragen müssen beantwortet werden
# Wie verteile ich Arbeit auf viele Cores ohne den Determinismus zu verlieren
# Wie schaffe ich eine Infrastruktur die Nativ Parallel ist aber stur sequenziell beschrieben und designed ist
Ziel ist die Steigerung der Latenz von Verarbeitungsschritten, die Latenz hat in der IT eine viel Grössere Bedeutung als die Performance. Das Grundkonzept ist, Verarbeitungsschritte, die gemacht werden müssen "auf später" zu verschieben, und dem rufenden Prozess "Scheinergebnisse" zu liefern.
Eine automatische Parallelisierung von "Schritt 1" und "Schritt 2" ist möglich wenn
* die beiden Schritte keine W-Zugriffe auf fremdgenutzte R-Elemente machen, also wenn ein Schritt keine Datengrundlage des anderen Modifiziert
* die beiden Schritte nicht von W-Werten des anderen abhängig sind. Also wenn "Schritt 2" eine R-Zugriff auf einen Wert macht, den "Schritt 1" beschreibt. In so einem Fall muss "Schritt 1" zumindest bis zum letzten W auf diesen Wert VORHER ausgeführt werden (Context-Block!).
==== Context-Freeze ====
Merke Dir den Schrittzähler im Eingangsmoment zu "Schritt 1". Sollten nachfolgende Schritte massiv die R-Basis von "Schritt 1" beschreiben kann immer noch ein korrektes Ergebnis erzielt werden wenn
* nachfolgende Schritte nach R Zugriffe auf das W des ersten Schrittes machen
* der erste Schritte alle R Zugriffe im Context des gespeicherten HBs machen
==== Sofortiger Rücksprung ====
Bei einer Read-Only Operation ohne Rückgabewert kann sofort zurückgesprungen werden. Anstelle des Rückgabewertes kann ein "Call Back Token" zurückgegeben werden, das sicherstellt dass wenn etwas auf das Ergebnis zurückgreift dass er erst Einblick erhält wenn die Verarbeitung abgeschlossen ist.
Der Zugriff auf R-Objekte muss im aktuellen Heartbeat-Kontext erfolgen, also alle Objekte müssen im Moment des Verarbeitungsbeginnes eingefrohren werden.
Ev. kann die Funktion selbst ein "R-Lock" auf Objekte setzen, die es braucht. Wenn andere Prozesse auf diese Objekte nun schreiben wollen muss die Verarbeitung vorrangig abgeschlossen werden.
Vor Rücksprung sollten immer Vorbedingungen der Operation geprüft werden, ist also die Durchführung der Aktion möglich und es kann eine Exception ausgeschlossen werden kann dem rufenden der Erfolg gemeldet werden, was er nicht weis ist, dass die Aktion noch gar nicht "wirklich" durchgeführt ist.
=== Interface-Ablauf ===
==== Call ====
Der Client iniziiert einen Call über http. Es sendet seinen Cache ID im etag mit. Dem Server seht es frei diesen eTag zu bestätigen oder ihn zuverwerfen.
==== Feedback ====
Zusammen mit dem Client-Call wird ein Feedback Callback (optionales) installiert. Dies ist nur sinnvoll für Routinen die während ihres Ablaufes Infos an den rufenden zurückgeben wollen oder müssen. Damit liefert der Server Zwischen Infos seiner Bearbeitung ab. Dies ist für das Logging wichtig. Bei langdauernden Aktionen des Servers dient das Feedback Interface zum Bewegen der Fortschrittsanzeige. Dabei achtet der Server darauf nicht zu oft feedback zusenden.
Eine Variante des Feedback-Interfaces ist einfach eine "Diagnose.txt" die nach Abschluss der Funktion üder den Dateisystem-Sync übertragen ist.
Das feedback Interface ist analog zur XMLRPC Schnittstelle definiert. Sie kann also auch "remote" ablaufen:
feedback :    TXMLRPC_Method;
TXMLRPC_Method = function(sParameter: TStringList): TStringList of object;
* '''Log(s)''' gibt s als Log aus
* '''Info(s)''' gibt s als aktuelle Aktion aus
* '''Progress(BarName,)'''
* '''Inquire (s)''' Rückfrage
Im Rahmen der Ausführung eines Aufgabe (oder auch einfach so?!), sollte der Server die Möglichkeit haben eine kurze Rückfragen an den Client zu stellen. Die Ausführung stoppt so lange beim Server bis die Nachfrage beantwortet ist.
Dies könnte durch das normale Feedback INterface abgewickelt werden.


== Team-Entwickler ==
== Team-Entwickler ==


Für das Gesamtkunstwerk OrgaMon wird ein zentrales Git-Repository geführt. Der Read Only Zugriff ist anonym möglich. Schreibenden Zugriff erhalten Entwickler nach Kontakt zum OrgaMon-Maintainer Andreas(Punkt)Filsinger(bei)orgamon(Dot)org .
Für das Gesamtkunstwerk OrgaMon wird ein zentrales Git-Repository geführt. Der Read Only Zugriff ist anonym möglich. Forke das Repository in deinen eigenen GitHub-Account. Mache von diesem Repository ein Git-Clone auf deine lokale Platte. Entwickle auf diesem Verzeichnis. Änderungen per Poll-Request an das Original OrgaMon-Repository. Der Maintainer Andreas(Punkt)Filsinger(bei)orgamon(Dot)org meldet sich dann. Es ist ein Lizenzbruch an OrgaMon zu entwickeln und die Arbeit nicht in das Original Repository zurückfliessen zu lassen. Bitte komme dieser moralischen Verpflichtung nach


* Web-Interface: https://github.com/Andreas-Filsinger/OrgaMon
* Web-Interface: https://github.com/Andreas-Filsinger/OrgaMon
Zeile 270: Zeile 52:


=== Installation ===
=== Installation ===
==== einfach mal zum testen ====


* Lade Dir TortoiseGIT herunter (http://tortoisesvn.net/downloads) und installiere es
* Lade Dir TortoiseGIT herunter (http://tortoisesvn.net/downloads) und installiere es
* Erstelle in "Eigene Dateien"->RAD Studio->Projekte ein neues Verzeichnis mit dem Namen "OrgaMon" (kann auch woanders liegen oder auch anders lauten!) und öffne es (ANMERKUNG: Es MUSS sich wegen eines Bugs im TortoiseSVN auf einer LOKALEN Platte befinden, Samba Shares gehen nicht!!!!)
* Erstelle in "Eigene Dateien"->RAD Studio->Projekte ein neues Verzeichnis mit dem Namen "OrgaMon" (kann auch woanders liegen oder auch anders lauten!) und öffne es (ANMERKUNG: Es MUSS sich wegen eines Bugs im TortoiseGIT auf einer LOKALEN Platte befinden, Samba Shares gehen nicht!!!!)
* Rechtsklicke in das offene Verzeichnis in den leeren Bereich und wähle "SVN Checkout"
* Rechtsklicke in das offene Verzeichnis in den leeren Bereich und wähle "Git Clone"
* Als Repository gebe "svn://orgamon.org/orgamon" an
* Als Repository gebe <code>https://github.com/Andreas-Filsinger/OrgaMon.git</code> an
* Vergewissere Dich, dass Dein "Check Out Directory" (eigentlich das Target Dir!) das eben angelegte "OrgaMon" ist
* Vergewissere Dich, dass Dein "Check Out Directory" (eigentlich das Target Dir!) das eben angelegte "OrgaMon" ist, und nicht OrgaMon/OrgaMon sein wird
* Drücke OK, alle Optionen einfach so lassen!
* Drücke OK, alle Optionen einfach so lassen!
==== wenn man mitentwicklen will ====
* Dann braucht man einen GitHhub Account, also schnelll registrieren
* Man macht einen Fork des Repositorys OrgaMon
* Man macht vom Eigenen Fork einen "Git Clone" ins lokale Verzeichnis
* Man macht Änderungen/Test und immer mal wieder ein Commit, damit Änderungen sinnvoll ins eigene Repository fliessen


=== täglicher Arbeitsablauf ===
=== täglicher Arbeitsablauf ===
Zeile 283: Zeile 74:


* rechter Mausklick auf Dein OrgaMon-Verzeichnis
* rechter Mausklick auf Dein OrgaMon-Verzeichnis
* "SVN Update"
* "Git Sync" ... danach weitere Schritte


-> Du bist nun auf dem neuesten Stand!
-> Du bist nun auf dem neuesten Stand!
Zeile 305: Zeile 96:
Man sollte erst mal alles zu Ende bringen, also alle Hinzunahmen erst mal zu Ende bringen. Nun muss man
Man sollte erst mal alles zu Ende bringen, also alle Hinzunahmen erst mal zu Ende bringen. Nun muss man


* auf neue Verzeichnisse einen rechten Mausklick machen und "TortoiseSVN" -> "+ add" ausführen, jetzt hat man die Chanche Datei-Extensions, die man nicht auf dem Server haben will zu demarkieren (default ist "Alles angekreuzt"). Nach einem OK wir im lokalen Repository zunächst mal der neue Content als überhaupt "SVN-relevanter" Content beachtet. Der Fragezeichenstatus geht über in ein fettes blaues Plus.
* auf neue Verzeichnisse einen rechten Mausklick machen und "TortoiseGIT" -> "+ add" ausführen, jetzt hat man die Möglichkeit Datei-Extensions, die man nicht auf dem Server haben will zu demarkieren (default ist "Alles angekreuzt"). Nach einem OK wir im lokalen Repository zunächst mal der neue Content als überhaupt "SVN-relevanter" Content beachtet. Der Fragezeichenstatus geht über in ein fettes blaues Plus.
* neue Dateien, die noch ein blaues Fragezeichen haben muss einzeln ge "+ add"ed werden.  
* neue Dateien, die noch ein blaues Fragezeichen haben muss einzeln ge "+ add"ed werden.  


Zeile 312: Zeile 103:
==== Release erzeugen ====
==== Release erzeugen ====


* mache diesen Schritt sobald all deine Test erfolgreich laufen
* mache diesen Schritt erst sobald all deine Test erfolgreich laufen
* Nebeneffekte deiner Release sollten ausgeschlossen sein, wenn unsicherheiten bestehen bitte Andreas Filsinger kontaktieren
* Nebeneffekte deiner Release sollten ausgeschlossen sein, wenn unsicherheiten bestehen bitte Andreas Filsinger kontaktieren
* "SVN Update" auf die Projekt-Datei im Rev-Verzeichnis (z.B. OrgaMon.rev.txt)
* Editiere die zum Projekt passende .rev.txt Datei aus dem Pfad /rev
* Mache oben neu Einträge im Stile der anderen alten Einträge
* Ab .SQL Init kannst Du SQL Befehle zum Metadaten Update hinzugeben
* In Globas.pas (oder in jedem Projekt eigentlich anders) erhöhe die Versionnummer auf die Angabe in der Rev-Datei
* Rev-Datei nun laden und eine Version hochzählen (und merken) und einen neuen Eintrag machen
* Rev-Datei nun laden und eine Version hochzählen (und merken) und einen neuen Eintrag machen
* in "globals.pas" die gemerkte Version Nummer eintragen
* in "globals.pas" die gemerkte Version Nummer eintragen
Zeile 320: Zeile 114:
* Autoup und ab damit
* Autoup und ab damit
* Nun all deine Änderungen committen: rechter Mausklick auf das Repository Haupt-Verzeichnis  
* Nun all deine Änderungen committen: rechter Mausklick auf das Repository Haupt-Verzeichnis  
* "SVN Commit"
* dokumentiere in der Msg-Box dein Patch-Set
* dokumentiere in der Msg-Box dein Patch-Set
* "GIT Commit"


optional
optional


* anschliessender "SVN Update", denn andere waren in der Zwischenzeit nicht untätig
* anschliessender Merge (bitte das hier korrigieren) damit auch Du wieder die Änderungen der anderen bekommst
* dies erhöht die Chanche dass Dein nächster "Update" / "Commit" problemlos durchläuft


=== Bedeutung der Verzeichnisse ===
=== Bedeutung der Verzeichnisse ===
Zeile 369: Zeile 162:


* Die Lösung 2103 liegt sauber in unserem Zeitfenster!
* Die Lösung 2103 liegt sauber in unserem Zeitfenster!
[[CMS.Dateiablage]]


=== TO DO ===
=== TO DO ===

Aktuelle Version vom 12. August 2024, 18:54 Uhr

Software ist in der modernen Welt zu wichtig, um nicht als Open-Source entwickelt zu werden.
[Linus Torwalds]
Freie Software ist die Basis für IT-Sicherheit
[Richard Stallman]

OrgaMon, unterstützte Betriebssysteme

  • Win32, Windows 2000, XP, Vista, Windows 7, Windows 10
  • Linux über die Emulations-Schicht Wine ab 0.98.5
  • Virtualisierte Windows 10 Systeme (via Linux.kvm)

OrgaMon-App, unterstützte Betriebssysteme

  1. Andorid 2.3 oder besser

Datenfunknetz

technische Infos für Entwickler

OrgaMon, Summer of Code

OrgaMon-RC

Team-Entwickler

Für das Gesamtkunstwerk OrgaMon wird ein zentrales Git-Repository geführt. Der Read Only Zugriff ist anonym möglich. Forke das Repository in deinen eigenen GitHub-Account. Mache von diesem Repository ein Git-Clone auf deine lokale Platte. Entwickle auf diesem Verzeichnis. Änderungen per Poll-Request an das Original OrgaMon-Repository. Der Maintainer Andreas(Punkt)Filsinger(bei)orgamon(Dot)org meldet sich dann. Es ist ein Lizenzbruch an OrgaMon zu entwickeln und die Arbeit nicht in das Original Repository zurückfliessen zu lassen. Bitte komme dieser moralischen Verpflichtung nach

Installation

einfach mal zum testen

  • Lade Dir TortoiseGIT herunter (http://tortoisesvn.net/downloads) und installiere es
  • Erstelle in "Eigene Dateien"->RAD Studio->Projekte ein neues Verzeichnis mit dem Namen "OrgaMon" (kann auch woanders liegen oder auch anders lauten!) und öffne es (ANMERKUNG: Es MUSS sich wegen eines Bugs im TortoiseGIT auf einer LOKALEN Platte befinden, Samba Shares gehen nicht!!!!)
  • Rechtsklicke in das offene Verzeichnis in den leeren Bereich und wähle "Git Clone"
  • Als Repository gebe https://github.com/Andreas-Filsinger/OrgaMon.git an
  • Vergewissere Dich, dass Dein "Check Out Directory" (eigentlich das Target Dir!) das eben angelegte "OrgaMon" ist, und nicht OrgaMon/OrgaMon sein wird
  • Drücke OK, alle Optionen einfach so lassen!

wenn man mitentwicklen will

  • Dann braucht man einen GitHhub Account, also schnelll registrieren
  • Man macht einen Fork des Repositorys OrgaMon
  • Man macht vom Eigenen Fork einen "Git Clone" ins lokale Verzeichnis
  • Man macht Änderungen/Test und immer mal wieder ein Commit, damit Änderungen sinnvoll ins eigene Repository fliessen

täglicher Arbeitsablauf

Beginn

  • rechter Mausklick auf Dein OrgaMon-Verzeichnis
  • "Git Sync" ... danach weitere Schritte

-> Du bist nun auf dem neuesten Stand!

Coding & Test

  • öffne z.B. mit Delphi ./OrgaMon/OrgaMon.dproj
  • editiere Dateien wie bisher
  • mache alles wie bisher, teste alles gut ...

-> wenn Deine Änderungen Release-Fähig sind ...

Löschen von Dateien

bei einem Commit sind Löschungen nicht automatisch im Änderungsauftrag an den Server mit dabei: Es reicht aber "select / deselect all" anzukreuzen, alternativ kann bei jeder gewünschten Löschung ein Haken gesetzt werden.

Hinzunahme neuer Dateien

ACHTUNG: Jeder neue Content (neue Verzeichnisse / neue Dateien) wird erkannt jedoch muss wie bei der Löschung das "select / deselect all" angekreuzt werden, dass überhaupt der Content übertragen wird. Bei dieser Verfahrensweise bekommen jedoch andere Entwickler diese neuen Dateien nicht zu Gesicht. Es muss hier mehr getan werden:

Man sollte erst mal alles zu Ende bringen, also alle Hinzunahmen erst mal zu Ende bringen. Nun muss man

  • auf neue Verzeichnisse einen rechten Mausklick machen und "TortoiseGIT" -> "+ add" ausführen, jetzt hat man die Möglichkeit Datei-Extensions, die man nicht auf dem Server haben will zu demarkieren (default ist "Alles angekreuzt"). Nach einem OK wir im lokalen Repository zunächst mal der neue Content als überhaupt "SVN-relevanter" Content beachtet. Der Fragezeichenstatus geht über in ein fettes blaues Plus.
  • neue Dateien, die noch ein blaues Fragezeichen haben muss einzeln ge "+ add"ed werden.

Vor einem "Commit" sollten also alle "hängenden" Stati ordentlich in echte Stati "add" oder "ignore" umgesetzt werden!

Release erzeugen

  • mache diesen Schritt erst sobald all deine Test erfolgreich laufen
  • Nebeneffekte deiner Release sollten ausgeschlossen sein, wenn unsicherheiten bestehen bitte Andreas Filsinger kontaktieren
  • Editiere die zum Projekt passende .rev.txt Datei aus dem Pfad /rev
  • Mache oben neu Einträge im Stile der anderen alten Einträge
  • Ab .SQL Init kannst Du SQL Befehle zum Metadaten Update hinzugeben
  • In Globas.pas (oder in jedem Projekt eigentlich anders) erhöhe die Versionnummer auf die Angabe in der Rev-Datei
  • Rev-Datei nun laden und eine Version hochzählen (und merken) und einen neuen Eintrag machen
  • in "globals.pas" die gemerkte Version Nummer eintragen
  • nochmals compilieren
  • Autoup und ab damit
  • Nun all deine Änderungen committen: rechter Mausklick auf das Repository Haupt-Verzeichnis
  • dokumentiere in der Msg-Box dein Patch-Set
  • "GIT Commit"

optional

  • anschliessender Merge (bitte das hier korrigieren) damit auch Du wieder die Änderungen der anderen bekommst

Bedeutung der Verzeichnisse

  • anfix32 (*.pas Tools)
  • PHPincludes (*.php Tools)
  • rev (Die Revision-Dateien)
  • OrgaMon (*.pas der OrgaMon-win32-Client)
  • MonDaServer (*.pas ein Server)
  • Oc (*.pas ein Kommandozeilen Tool)
  • aqbd (*.c ein HBCI Dämon)
  • TWebShop (*.php5 der OrgaMon Webshop)

Konzepte

RAIB

Datum

Noch immer ist die Unsitte verbreitet Datumsangaben im Bezug auf das Jahr nur 2 stellig anzugeben, als man schenkt sich das Jahrhundert, in dem wir leben! Also einen Datumsangabe wie z. B. 

10.10.10

hm, ist das jetzt der 10.10.1910 oder 10.10.2010. Das kann man nun je nach Kontext (als Mensch) sehr gut entscheiden. Der OrgaMon legt hier folgende Vereinbarung zu Grunde:

  • Gehe vom aktuellen Jahr aus und rechne ein Menschenalter (75 Jahre) zurück, dies ist das Startdatum für 2 stellige Jahresangaben
  • Gehe vom aktuellen Jahr aus und rechne eine Menschengeneration (24 Jahre) vor, dies ist das Endedatum für 2 stellige Jahresangaben


z.B. 10.10.10
  • Es sei das Jahr 2025: Zeitraum ist somit also 1955 bis 2054
  • das bedeutet die Lösung ist entweder 1910 oder 2010
  • da nur 2010 im vorberechneten Zeitfenster liegt ist dies das Ergebnis!

Kann es sich auch mal auf das kommende Jahrhundert beziehen? JA. Sagen wir jemand sagt: Am 10.10.03 steigt die grösste Party aller Zeiten! Nehmen wir an, es ist das Jahr 2099, also 

2099 - 75 = 2024 StartJahrhundert
2099 + 24 = 2123 EndeJahrhundert
  • Die Lösung 2103 liegt sauber in unserem Zeitfenster!

TO DO

  • FlexCell und IBObjects Wegfall
  • Nach der Funktionsprüfung von lOrgaMon.exe (FreePascal-Win32-Konsolenanwendung) soll das Compile-Target "Linux" geprüft werden.
  • Bestandteile der Dienste "Mail", "Tagwache", "Tagesabschluss" sollen Stück für Stück in den lOrgaMon Code wandern.
    • --Indexerstellung
    • --FTP-Uploads
    • --Backup / --restore
    • --tagwache
    • --tagesabschluss

SEPA-Probleme

bisher 

'ABSCHLUSS PER 31.03.2011'#$D#$A
'SALDO RECHNUNGSABSCHLUSS'#$D#$A
'            PER  31.03.2011'#$D#$A
'INCL. ABSCHLUSSBETRAG'#$D#$A
'                     303,49'#$D#$A

neu 

'ABSCHLUSS PER 31.12.2015SALDO RECHNUNGSABSCHLUSS            PER  30.12.2015INCL. ABSCHLUSSBETRAG                     763,52'#$D#$A

Aufsplittung 


'ABSCHLUSS PER 31.12.2015'
'SALDO RECHNUNGSABSCHLUSS'
'            PER  30.12.2015'
'INCL. ABSCHLUSSBETRAG'
'                     763,52'
  • Also was die Banken machen ist gegen jedes IT-Verständnis
    • die einst mehrzeiligen Verwendungszwecke werden zu einer langen Zeile zusammengefügt, dabei werden
      • Blanks links des ersten Zeichen erhalten
      • Blanks rechts des letzten Zeichens gelöscht

TOLL!!! Gut gemacht

Abgerufen von „https://wiki.orgamon.org/index.php?title=Entwickler&oldid=32756“