OrgaMon-next

• OrgaMon setzt wo immer möglich die Programmiersprache Object-Pascal ein.
• Als Compiler wird nur noch Free-Pascal eingesetzt
• Es werden nur noch Open-Source Komponenten eingesetzt
• der eCommerce-Kernel soll Schritt für Schritt Kopplungspunkte bekommen wobei Kunden dann Anpassungen machen können. Das Customizing sollte aber auch wieder Open-Source sein und auch Test-Cases beinhalten so dass es für andere Kunden Regeressionsfrei bleibt. Lazarus soll auch für Kunden eine Möglichkeit sein, auf den Code einfluss zu nehmen.

OrgaMon UI

UI Ideen

ein Projekt, das zum Ziel hat den OrgaMon mit einer Plattform-übergreifenden GUI anzubieten

farbige Tabs

• Tab sind erst mal nicht da, können aber aus einem Suchbegriff oder einem Befehl frisch erzeugt werden. Wird z.B. ein Vertrag angewendet entstehen ev. ganz viele neue Beleg, ein Beleg wir als ein einzelner Tab angezeigt.
• Standard-Aktionen sind auf Tabs anwendbar und können als transaktion auf Gruppen von TAbs angewendet werden.
• Eine aktuell eingerichtete Tab-Gruppe (3 Personen und 2 Beleg und 1 Vertrag) kann in einer Tab-Historie gespeichert werden.
• Tab-Favoriten gibt es auch, auf die "Umgeschaltet" werden kann aber auch "dazugeladen" werden kann.
• man kann mehrere Belege öffnen und gleichzeitig bearbeiten. Dazu "Zieht" man sich einen neuen Tab. Tabs aus der selben Gruppe haben die gleiche Farbe und sind immer zusammen angeordnet (Gruppe schliessen).
• Es gibt einen Neu Tab.
• Ein Langer gehaltener Klick auf einen Tab erzeugt einen "Drag"-Event
• https://addons.mozilla.org/de/firefox/addon/tab-kit/

Tab-Funktionen

• Anklicken: Der Tab-Inhalt kommt nach vorne, jetzt erst wenn der TabInhalt sichtbar ist wird das kleine "close" sichtbar.
• Schliesst man den Browser mit offenen Tabs muss am nächsten Tag ein reconnect erfolgen mit allen Inhalten parat!!!

Progressbereich

• zeigt zentral aktuelle Wartezeiten an, im Hilfehinweis oberhalb laufen Log meldungen
• ich bin unsicher, ob dies durchführbar ist, aber ich will eine Unstoppable GUI die einfach nur Anforderungen an eine Exekutive weitergibt. In dem Progressbereich stapeln sich einfach Aufgaben, die im Moment am laufen sind und noch nicht abgeschlossen (Beispiele Dafür: Tagwache auf einem Server, Tagesabschluss auf einem Server, Anwendung von Verträgen usw.)

Suchbereich

OrgaMon ist (wieder) über Hotkeys steuerbar: <ctrl>PN macht "Person" "neu" der Focus steht beim Vornamen usw.

blauer Aqua-Button

der Start-knopf des OrgaMon, hier kommen die ganzen früheren Menü Möglichkeiten

UI Implementierung

• 22.12.2016: Das Konzept des OrgaMon 9 steht:
• GUI ist ...
• immer ein Firefox-Client ab Rev. 50+ (KEINE AUSREDEN, KEIN EDGE, KEIN CHROME, einfach eine Blank Screen in dem Fall!! PUNKT)
• immer https:// (https/2)
• Serverprozess ist cOrgaMon
• immer systemd Socket Aktiviert, für JavaScript-Debug Zwecke öffnet er auch mal einen einen eigenen Socket
• immer html5 und JavaScript, immer generiert aus eigenen Quellen, nach Möglichkeit keine Meta-Ebene auf dem Client, alles direkt und "nativ"
• immer eine lang stehende Keep-Alive TCP Verbindung, mit Full Reconnect und Client-IP-Change Möglichkeit
• kein HTTPS Server dazwischen (z.B. Apache oder nxing)
• eigene Session Verwaltung über die Datenbank
• Die Bedienelemente sollen ganz einfach beginnen und dann Schritt für Schritt mächtiger werden
• Der Server soll ETAG fähif sein, insbesondere für Daten-Requests, Also: Der Client frägt ein Dataset ab, ist es unverändert bekommt er nur das ETAG

erste Schritte

• ein Fenster mit einer Schaltfläche:

offene Fragen: =

• Wie das lokale Dateisystem angesprochen werden soll weiss ich noch nicht
• Wie das Design der Fomulare erfolgen soll weiss ich noch nicht (also mit welcher IDE, XML Definitionen, ...) Formulare sollen jedoch in der Datenbank stehen
• In einer Übergangsphase soll ein Webkit in den OrgaMon.exe integriert werden (der OrgaMon wird z.B. auch einen Magnetstreifen scannen müssen, oder Datensicherung machen, oder den Computernamen abfragen, oder?)

HTML5-
Client  <--https/2--> systemd Socket Activation <---sd_listen_fds()---> hOrgaMon Web Server    <--fbclient----> FirebirdSQL
                                                                        (links libsystemd.so)   +--file I/O---> .\OrgaMon\

UI Benutzer-Grundgesetz

Im Zentrum einer GUI müssen unverhandelbare Grundrechte des Benutzers / Bedieners stehen. Auswüchse die es im Moment gibt (Wir sind immer noch in der IT-Steinzeit) müssen verhindert werden.

§1 Klickbarkeit

Ist ein Text oder ein Bild oder ein Icon anklickbar, so muss es in einer deutlich sichtbaren Weise grafisch ausgeprägt werden, das dies deutlich wird. Bei einem MoveOver muss sich auch der Zeiger ändern.

§2 Fokus

Der Eingabefokus darf niemals programmgesteuert dem aktuell sichbaren Eingabefeld entzogen werden. Das Einblenden eines Meldungsfensters während der Benutzer eine Eingabe tätigt ist ein solcher Fokusentzug. Ein Notifikationsbereich ist erlaubt.

§3 Eingabesicherheit

Direktes Abändern/Verfälschen der Eingabe, also automatisches Vervollständigen, automatisches Setzen eines Punktes usw. ist nicht erlaubt.

§5 Sichtbarkeit

Eingabebereiche dürfen nicht unmotviert überdeckt oder verschoben werden. Bei einer Grössenänderung muss das Zentrum (=Position des Eingabe-Cursors) beibehalten werden.

§5 Klicksichtbarkeit

Ein Klick auf Controls, die erst wenige ms sichtbar sind, darf nicht als eingabe gewertet werden. ALso wenn ein neu sichtbares Fenster eine alte GUI überdeckt und sich der Benutzer für einen Klick entschieden hat darf das neue Fenster diesen Klick-Event nicht verarbeiten.

§6 Reaktivität

Die GUI darf niemals auf Ergebnisse des Arbeitsprozesses warten, der Job wird an der Theke abgegeben, die GUI ist sofort wieder aktiv.

§7 Feedback

Ausgelöste Aktionen muss ein Feedback auf der GUI erzeugen

§8 Pausen

Jede Eingabe muss zurückgestellt werden können. Eingaben auf anderen Formularen müssen dann möglich sein

§9 Variante

Jedes Formular muss dupliziert werden können. Es muss Testeingabe / Versuche verkraften ohne dass eine Aktion durchgeführt wird, erst anschließendes "Buchen" führt zur Aktion oder eben "Abbruch"

§10 Rückgängig

Jede lokale Eingabe die noch nicht "abgeschickt" ist, muss rückgängig gemacht werden können

ServerSide-ClientSide

• Es ist mir klar dass Clientside Code in JavaScript bekommen muss, ich will aber dennoch in .pas Modulen diesen Code in Pascal Programmieren.
• Motto: "Es gibt nur ein Rudi Völler"
  • Es muss also der Pascalcode in JavaScript umgewandelt werden
  • Es muss klar sein, dass dieser Code auf der ServerSeite ga nicht ausführbar ist, bzw. erreichbar ist
  • Ich hab noch keine Ahnung wie genau das funktionieren soll
  • Es soll alles in der Lazarus IDE programmierbar sein
  • Es soll alles auch in der Lazarus IDE mit Break-Points programmierbar sein, die IDE soll ein Verständnis haben welche Zeile welchen Code verbirgt

program SimpleCalculator;

var
 Panel : TPanel;
 Button1 : TButton;
 Button2 : TButton;
 
procedure Panel.OnClick;
begin
 beep; // This goes to JavaScript Client Code
end;

procedure Button1.OnClick;
begin
 Button2.Disable; // This goes to JavaScript Client Code
end;

procedure Button1.OnClick;
begin
 Button2.Disable; // This goes to JavaScript Client Code
end;

begin
 App.add(Panel);
 App.add(Button1);
 App.add(Button2);
end.

• die IDE soll ein Verständnis haben dass auf Client-Seite nicht "alles" Programmierbar ist
• aus den JavaScript Parts soll über einen Dispatcher der nonGUI Code aufbar gemacht werden
• In einer Datenbank soll das Know-How für die Web Objekte gespeichert sein

Debugging

• Interessant wird es beim Debugging. Hier muss der WebClient in den remote-Debugging Modus gebracht werden
• Es könnte die Infrastruktur der "Source maps" verwendet werden, also "komprimierte" Zeilen des JavaScript Quellcodes zeigen auf die entsprechenden Zeilen, die in FreePAscal formuliert sind
• FreePascal und die Lazarus IDE müssen lernen, dass Teile vom Quelltext "remote" executables sind
• FreePascal Lazarus muss Möglichkeiten bieten von einem eintretendem JAvaScript Breakpoint gerufen zu werden

Interface-Caching

sagen wir mal, wir haben:

type
 DataModuleeCommerce = class(GhostAbleInterface)
 
 published
  TodaySettings : TStringList;
 end;

wir sagten ja ein lokaler OrgaMon kann auf TodayStrings zugreifen, als wäre das lokal

Paralleles Arbeiten

• Klar ist: Ein OrgaMon Prozess ist für eine dauerhafte TCP/Connection zuständig
• Möglicherweise startet dieser Prozess auf dem Server SubProgramme mit langen Laufzeiten
• Rückmeldungen dieser lang laufenden Prozesse ev. über https://developer.mozilla.org/de/docs/Web/API/Push_API

fetch()

https://fetch.spec.whatwg.org/

• Alle Server Anforderungen gehen sofort zunächst in einen Sync-Buffer
• Wenn mögich wird der Sync-Buffer Asynchron abgearbeitet
• Mit dem Server wird per fetch() gesprochen
• Ein Fetch kann misslingen
  • IP Change
  • Server Process Crash
  • Client Internet Connection Gab
  • Dies darf aber niemals zum Problem werden

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/

Dienst-Übersicht

• firebird
• samba
• memcached
• Apache2
• OrgaMon Instanz "Tagesabschluss"
• OrgaMon Instanz "Tagwache"
• OrgaMon Instanz "Kasse" (Buchen + Drucken)
• OrgaMon Instanz "eMail"
• JonDaServer
• OrgaMonApp-Service
• Instanz OrgaMonAppService "PDF Erstellung aus html"
• 4x cOrgaMon XMLRPC fürs Web
• hbci-Server
• osm-Server

• mod_asis geht ev. Hand in Hand mit dem etag Caching System
• Proxy VOR den einzelnen mandanten http://httpd.apache.org/docs/2.0/mod/mod_proxy.html
• Kompression mit Hilfe von zlib und Standard HTTP Techniken

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

1. Wie verteile ich Arbeit auf viele Cores ohne den Determinismus zu verlieren
2. 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.

Links

• FreePascal GTK+ Binding
• http://wiki.freepascal.org/Qt4_binding
• http://www.rodi.dk/programming_cairo.php
• http://wiki.lazarus.freepascal.org/
• http://www.fox-toolkit.org/
• http://gsl.openoffice.org/vcl/index.html
• http://gsl.libreoffice.org/vcl/index.html
• http://www.phoronix.com/scan.php?page=news_item&px=ODgzMA
• http://www.micrel.cz/Dx/
• http://www.foss-group.ch/de/Anwendungen/OSBD/