Abou Chleih

{the magic lies between the brackets}

Menü Schließen

Seite 2 von 9

Migration von bestehender Check_MK Installation auf OMD

Da die Repositories von Debian nicht die aktuelle Version von Check_MK beinhalten, aber nur diese die Funktion besitzt SNMP Traps zu empfangen und auswerten, musste ich einen Server von einer manuellen Installation auf die OMD Installation umstellen und bestehende Daten migrieren.
Die Migration ist eigentlich sehr einfach.
Man nimmt die Daten aus dem Verzeichnis /etc/check_mk/ des alten Servers und kopiert diese auf den neuen in den Ordner /opt/omd/sites/{SITE}/etc/check_mk.
Danach überprüft man die Rechte und weist als Eigentümer (rekursiv) den Sitenamen {SITE} zu.
Danach sollten die Daten für das System beschreibbar sein.

Nun kann man sich einloggen, wird aber kurz darauf feststellen, dass die Rechte nicht stimmen. So ist der omdadmin bzw. sind die bestehenden User zwar existent, aber nicht in den richtigen Gruppen.
Also gehen wir in das Verzeichnis /opt/omd/sites/monitor/etc/check_mk, öffnet die Datei multisite.mk und fügt in der Zeile admin_users = [ ... ] den Punkt ,"omdadmin" zu.
Nun kann man die bestehenden User anpassen und die Rechte zuweisen.

Fertig! Die groben Einstellungen sind nun importiert. Dienste oder Spezialabfragen über Plugins müssen allerdings, falls versch. Nagios Versionen, neu geschrieben/installiert werden.

Pluginsverzeichnis für Check_MK ist /usr/lib/nagios/plugins. Die eigenen Plugins in diesem Verzeichnis müssen nun in das Verzeichnis von OMD kopiert werden /opt/omd/versions/1.20/lib/nagios/plugins.

Nun muss man noch die Rulesets in Check_MK entsprechend den neuen Verzeichnissen anpassen bspw.:

bash /usr/lib/nagios/plugins/my_Check_bla -H $HOSTADDRESS$ -C public -v 2c -t raid -w 90 -c 95

bash /opt/omd/versions/1.20/lib/nagios/plugins/my_Check_bla -H $HOSTADDRESS$ -C public -v 2c -t raid -w 90 -c 95

Nun sollte der Server wie gewohnt funktionieren.

Falls nicht, liegt es daran, dass der Server die alten, gecacheden Daten als valide ansieht und die neuen, da evtl. neuer Syntax, als invalide.
Beheben lässt es sich, indem man die Hosts neu prüfen lässt:

omd$mysite: check_mk -u
omd$mysite: check_mk -I {host}
omd$mysite: check_mk -v {host}

{host} ist optional, sollte das Argument nicht genannt werden, so wird der Task auf alle Hosts ausgeführt.

Natürlich müssen noch eventuell Freigaben bezüglich der Domänennamen oder IPs berücksichtigt werden. Bspw. SNMP Freigabe nur auf IP x.

Erste Schritte: Installation und Erstkonfiguration von Nagios3/Check_MK auf Debian 7.0

Um meine Windows Server 2008 R2 Server, sowie meine Virtualisierungsinfrastruktur (auf VMWare ESXI) zu monitoren, suchte ich nach einer einfachen, aber auch umfangreichen Lösung.
So stieß ich auf das sehr verbreitete Nagios Softwarepaket, welches allerdings erst mit vielen Plugins ausgestattet werden muss, um vernünftig zu funktionieren.
Daraufhin habe ich meine Suche fortgeführt und bin auf die Open Monitoring Distribution (kurz: OMD oder OMDistro) gestoßen, welche die wichtigsten Plugins und Softwarepakete in einem Paket zusammenfasst, die da wären:

  • Check_MK (umfangreiche Erweiterung auf Nagios)
  • Nagios3
  • NagVis (Visualisierungsplugin)
  • Thruk (WebInterface)
  • Icinga (WebInterface)

Ich habe mich jetzt hier aber für Check_MK und Nagios3 (logischerweise) entschieden.
Die Installation auf einem Grundsystem (hier: Debian 7.0) ist sehr einfach.

Eine statische IP Adresse muss in der network configuration gesetzt sein!

Zu aller erst lädt man sich die Distribution als .deb-Paket auf der offiziellen Website herunter und verbindet sich per SSH auf den Server.
Ich nutze im folgenden für den Datenverkehr auf den Server winSCP, welches auf SSH basiert.
Via winSCP kann man die Datei in das Verzeichnis „/usr/local/“ kopieren – natürlich sind auch andere Pfade möglich – und führt den Befehl zur Installation via gdebi aus:
gdebi /usr/local/omd-0.43_0.43lucid1_amd64.deb
Anschließend folgt man den Anweisungen, setzt die Kennwörter und konfiguriert das System.
Nach der Installation muss man noch überprüfen, ob das Modul „HTTP Redirects/Proxy“ aktiviert ist.
a2enmod proxy_http
Danach aber noch schauen, ob die Einstellungen in /etc/apache2/mods-enabled/proxy.conf richtig und sicher sind (Zugriff von außen blockieren).
Nun können wir die OMD starten, indem wir zuerst den Pfad noch festlegen, hier http://<IP>/Monitoring/:
omd create Monitoring
omd start

Nun navigiert man zu folgender Seite http://<IP>/Monitoring und sieht alle o.g. Funktionen.
Man navigiert nun zu Check_MK und geben die Admin Daten (Standarduser: omdadmin, PW: omd) ein.
Hier kann nun über die Schaltfläche Hosts, neue Hosts anlegen:

wato_hostscheckmk_newhost

 

Anschließend gibt man die Daten des Servers ein und wählt den Agent Type SNMP, wenn man SNMP nutzen möchte. Anschließend definiert man noch die Community und klickt dann auf „Safe & Go To Services“.
Hier bekommt man dann eine Fehlermeldung, dass keine Rückmeldung via SNMP stattfand

snmp_error

 

Man muss nun also noch SNMP auf dem Windows Server aktivieren.
Dazu verbindet man sich via RDP auf den Server, öffnet den Server Manager und navigiert zu Features und Feature hinzufügen.
Anschließend wählt man den SNMP-Dienst aus und lässt diesen installieren.
Nach der Installation öffnen wir die services.msc und navigieren zum Dienst „SNMP-Dienst“. Hier klicken öffnet man nun die Eigenschaften und definiert den Agent, sowie die die Community und akzeptierte Hosts:
snmp_1 snmp_2
Community ist hier: Check_MK (Rechte: NUR LESEN), die IP-Adresse des Nagios3-Servers ist 192.168.178.128, Kontakt und Standort kann man frei wählen.
Anschließend quittieren wir alles mit Übernehmen und OK.

In Check_MK können wir nun nochmals den Service-Scan ausführen und bekommen einige Infos über SNMP zugeschickt
checkmk_services

Jetzt speicher man alles und lässt die Änderungen aktiv werden:

activate_changes

Fertig! Der Server wird nun monitored und über das Dashboard lassen sich nun die Hosts überwachen.

Installieren und Konfigurieren von OpenWRT auf dem TP-Link WR710N

Der TP-Link WR710N war für kleine WLAN-Netze gut zu gebrauchen, ansonsten aber sehr langsam und instabil.
Da ich gute Erfahrungen mit meinem WR841N auf OpenWRT gemacht hatte, habe ich mich kurzerhand entschlossen auch den WR710N auf OpenWRT „umzurüsten“.
Dies ging leider nicht so einfach via Plug&Play.
Nun aber von Anfang an:

Achtung: Die Hardwareversion des TP-Link WR710N ist sehr wichtig, hier ist nur von der Version (EU) v1.1 die Rede!
Funktionalität von anderen HW-Versionen kann man hier erfahren.

Über das Repository kann man den aktuellsten Softwarestand herunterladen, in unserem Fall ist das  die openwrt-ar71xx-generic-tl-wr710n-v1-squashfs-factory.bin.

Über die Upgradefunktion der Weboberfläche unseres Routers wird die Binary-Datei, als das Update, nun aufgespielt.
Dies kann nun etwas dauern. Im Nachhinein ist der Router nur über TELNET (vorher als Putty herunterladen) über die IP 192.168.1.1 verfügbar.
Grundsätzlich ist kein root-Kennwort gesetzt und man gelangt direkt ins Terminal. Hier gleich ein sicheres (!) Passwort für den Root vergeben:
passwd

Nun muss man erstmal (sollte man ein eigenes Netz schon in Betrieb haben) die IP-Konfiguration vornehmen.
Dazu im Terminal die Datei /etc/config/network mit dem Editor vi bearbeiten.
vi /etc/config/network

Hier nun das Interface „lan“ wie gewünscht einstellen, also:
(Per ‚a‘ kommt man in das Bearbeitungsmenü, per ESC wieder ins Kommandomenü, zum Löschen einer Zeile ‚d‘ im Kom-Menü drücken)

option ipaddr 'x.x.x.x'
option gateway 'x.x.x.x'
option dns 'x.x.x.x'

Nun speichern wir per ESC + wq + Enter.

Anschließend startet man den Router per „Strom-Weg“ neu. (Der Init-Befehl  läuft bei mir leider immer in eine Boot-Schleife).
Nun kann man den Router per definierter IP-Adresse erreichen.
Will man jetzt die Weboberfläche Luci installieren, muss man opkg update ausführen.
Bei mir waren die Links in der opkg.conf veraltet, wodurch das Update bei allen Repos mit einem 404-Error abbrach.
Also muss man die /etc/opkg.conf wieder mit vi bearbeiten:
vi /etc/opkg.conf
und die Links mit diesen hier ersetzen, bsp:

src/gz barrier_breaker_base http://downloads.openwrt.org/barrier_breaker/14.07/ar71xx/generic/packages/base

Wichtig ist der aktuelle Link: http://downloads.openwrt.org/barrier_breaker/14.07/ar71xx/generic/packages

Danach nochmals opkg update ausführen.

Jetzt sollten alle Repos aktualisiert sein und man kann mit der Installation von Softwarepaketen beginnen.
So installiert man nun die Weboberfläche mit:
opkg install luci
Alle Dependencies werden hierbei direkt mitinstalliert.
Also noch den http-Server via /etc/init.d/uhttpd start starten und anschließend kann man das Webinterface besuchen, indem man die IP-Adresse per Webbrowser aufruft.
Optional, damit der HTTP-Server immer beim Booten startet:
/etc/init.d/uhttpd enable

Das war’s! Nun hat man einen vollständigen und stabilen Router mit VLAN-Fähigkeit, Firewall, VPN etc.

Grundlagen der Programmierung: Static Deklaration

Wann sollte man eine Klasse statisch deklarieren und was ist dieses Static eigentlich?
Behandeln wird einmal den zweiten Punkt und nehmen die Klasse Console.
Die Klasse Console besitzt die statische Methode Write().

 

Diese können wir also im Code aufrufen, ohne explizit eine Instanz der Klasse zu erstellen:

 Console.Write("Hello World");

Diese Deklaration nennt man static, da wir hier nicht explizit auf die Daten einer bestimmten Objektinstanz zugreifen, sondern die Daten immer gleich zurück gegeben werden. Unabhängig vom Zustand des Objektes, also von den Werten, welche einer Variable in dem Objekt gegeben werden.

 Console.Write("Hello World");

wird also immer „Hello World“ zurück geben!

Um eine Ausgabe in der Konsole zu tätigen, brauchen wir kein spezielles Console-Objekt, also nicht sowas:

 
Console c = new Console(); 
c.Write("Hello World"); // FALSCH

Wann benötige ich dann „normale“ Methoden und Variablen?

Das kommt in einem anderen Post ;)

Aussagenlogik in der Mathematik

In der Mathematik und der Informatik müssen Aussagen auf ihre Wahrheit hin untersucht werden.
Also muss man „schlicht“ herausfinden, ob die Aussage

  • wahr
  • falsch

ist.

Beispiel:
Aussage: 1 = 2 -> Diese Aussage ist falsch
Aussage: 4 = 4 -> Die Aussage ist richtig, also wahr

Schließt man Vermutungen aus, kann man dies mit beliebigen Aussagen fortführen. Es kann also jede Aussage entweder wahr oder falsch sein.

Wie in der Umgangssprache, so kann auch in der Mathematik eine Aussage verneint (negiert) werden. Kennzeichnen tut man dies mit ¬Aussage oder /Aussage sowie einem Negierungsstrich über dem A.

Beispiel: ¬(„Heute ist ein schöner Tag“) -> („Heute ist kein schöner Tag“)
Beispiel2: Aussage: „Die Lampe leuchtet“ => ¬(„Die Lampe leuchtet“) -> („Die Lampe leuchtet nicht“)

Also wird aus einer wahren Aussage eine falsche Aussage und vice versa.

Im folgenden werde ich für wahr eine 1 setzen und für falsch eine 0. Dies ist bei mir reine Gewohnheitssache, da ich aus der IT komme und dort mit boolschen Binärwerten (0/1) gearbeitet wird.

Wahrheitstabelle für Negation (NOT oder Nicht):

NOT

Ist eine Aussage wahr (1), so wird er falsch (0). Ist eine Aussage falsch(0), so wird sie wahr(1).

Sprechweise: ¬A ist die Negation von A.

Zur Wahrheitstabelle gibt es noch kurz etwas zu sagen, bevor wir richtig anfangen:
Wahrheitstabellen haben immer 2^n Möglichkeiten, wobei n für die Anzahl der Parameter steht. Im oberen Beispiel haben wir einen Parameter 2^1 = 2, also zwei Möglichkeiten. Bei zwei Parametern (Beispiel folgt nachher) haben wir 2^2 = 4 Möglichkeiten usw.
Dann müssen wir alle Möglichkeiten abdecken, indem wir jede mögliche Konstellation der Werte in diese Tabelle schreiben (A:01010101, B:00110011, C:00001111).
Auf die Werte in der Klammer gehe ich jetzt nicht weiter ein, aber mit etwas Nachdenken kommt man auf das System.

 Machen wir nun also weiter.

Wie in der Umgangssprache, gibt es auch in der Technik und Mathematik Aussagen die sich bedingen, die getrennt voneinander das gleiche Aussagen etc.

Für solche Bedingungen, gibt es die logischen Operatoren oder richtiger Junktoren, die da wären:

1.Konjunktion (AND / UND):

Diesen logischen Operator kann man sich wie eine elektronische Reihenschaltung mit zwei Schaltern vorstellen.

Reihenschaltung

Für die Nichttechniker: A und B sind Schalter, der Kreis mit dem Kreuz ist eine Glühlampe und die zwei parallelen Striche eine Energiequelle, bspw. eine Batterie

Der Stromkreislauf ist geschlossen, wenn beide Schalter geschlossen sind. Erst wenn dies der Fall ist leuchtet die Lampe.

Symbol: ∧, Beispiel: A∧B=C, gesprochen „Wenn A und B, dann C“.

Bauen wir uns dafür nun wieder eine Wahrheitstabelle mit zwei Eingängen („Schaltern“) A und B und einem Ausgang („Lampe“) A∧B

0 = Schalter nicht gedrückt bzw. Lampe leuchtet nicht, 1 = Schalter gedrückt bzw. Lampe leuchtet

AND

2. Disjunktion (OR / ODER)

Diesen logischen Operator kann man sich wie eine elektronische Parallelschaltung mit zwei Schaltern vorstellen.

Parallelschaltung

Der Stromkreislauf ist geschlossen, wenn einer der beiden Schalter geschlossen ist, also Schalter A oder Schalter B. Erst wenn dies der Fall ist leuchtet die Lampe.

Symbol: ∨, Beispiel: A∨B=C, gesprochen „Wenn A oder B, dann C“.

Bauen wir uns dafür nun wieder die entsprechende Wahrheitstabelle mit zwei Eingängen („Schaltern“) A und B und einem Ausgang („Lampe“) A∨B

OR

3. Implikation (Folgt-aus)

Die Implikation A=>B ist essentiell für mathematische Beweisführungen.

Allerdings wird es hier auch etwas komplizierter, denn zuerst einmal muss man sich etwas klar machen.

Nehmen wir an, man habe eine falsche Aussage, bspw. 2 = 5 (A) und nehme diese *2 -> 2*3 = 5*3 <=> 6 = 15 (B) ist immer noch falsch.
Also können wir sagen, dass eine falsche Aussage auch eine falsche Aussage implizieren kann.

Nehmen wir nun allerdings wieder (A) * 0 -> 2*0 = 5*0 => (keine Äquivalenz!) 0 = 0. Dies ist eine wahre Aussage!
Also können wir sagen, dass eine falsche Aussage auch eine wahre Aussage implizieren kann.

Sagen wir jetzt 2 = 2 (A) ist eine wahre Aussage. Und multiplizieren/addieren/dividieren/subtrahieren diese mit einer beliebigen Zahl, so kommt immer eine wahre Aussage heraus. (Bspw.: 2+2 = 2+2 <=> 4 = 4 -> wahr)
Also können wir sagen, dass eine wahre Aussage auch eine immer eine wahre Aussage impliziert.

Nehmen wir nun wieder diese wahre Aussage 2 = 2. Wir werden feststellen,  dass wir keine falsche Aussage aus dieser implizieren können.

Die Wahrheitstabelle sieht dann wie folgt aus:

Implikation

Symbol: =>, Beispiel: A=>B, gesprochen „A impliziert B“ oder „Aus A folgt B“.

4. Äquivalenz (Genau-wenn)

Symbol: <=>, Beispiel: A<=>B, gesprochen „A genau dann, wenn B“ oder „A ist äquivalent zu B“.

Herleiten können wir diese Wahrheitstabelle einfach, in dem wir eine falsche Aussage mathematisch versuchen mit Äquivalenzumforumgen (Subtraktion, Addition, Multiplikation (außer *0) oder Division) umzuformen, sodass dies eine wahre Aussage ergibt.
Es wird uns nicht gelingen.
Auch anders herum wird es uns nicht gelingen. Denken wir nochmals an die Implikation: Dort habe man nur eine falsche Aussage in eine wahre umformen können, indem ich mit 0 multiplizierte, was nicht äquivalent ist. Denn man kann diese Operation nicht mehr rückgängig machen.

Daraus folgt:

Aequivalenz

Wichtige Begriffe in der Aussagenlogik:

  1. Tautologie = eine Aussage, die immer wahr ist.
  2. Junktoren = logische Operatoren
    1. zweistellige Junktoren:  ⇔, ⇒, ∨, ∧
    2. einstellige Junktoren: ¬

Neben den bisher eingeführten Verknüpfungen gibt es noch weitere, welche vorwiegend in der  Informations- und Digitaltechnik eingesetzt werden.

Sätze der Aussagenlogik:

Sätze von De Morgan:

  • ¬(A∧B) ⇔¬A∨¬B
  • ¬(A∨B) ⇔¬A∧¬B

Kontrapositionssatz:

  • (A⇒B) ⇔ (¬A⇒¬B)

Distributivsatz:

  • A∧(B∨C) ⇔(A∧B)∨(A∧C )
  • A∨(B∧C) ⇔(A∨B)∧(A∨C )

SQL Datenbanken in Windows Phone 8 nutzen

Man kann Daten in Projekten auf vielfältige Arten speichern, eine davon ist die Hinterlegung der Daten in einer Datenbank.
Dazu gibt es in Windows Phone mehrere Optionen. Das bekannteste und weit verbreitetste Datenbank-Datenbanksystem  ist SQLite.
Sie ist open-source und kann kostenfrei in Projekten eingesetzt werden. Zudem hat SQLite den Ruf sehr stabil und schnell zu laufen.

Wieso soll ich denn überhaupt eine Datenbank nutzen?

Das muss man nicht, aber ab einer bestimmten Komplexität der Daten/Informationen, ist eine Datenbank sinniger, als ein „plumpes“ Hinterlegen der Informationen in Dateien, bspw. über XML oder JSON.

Beginnen wir…
Grundsätzlich gibt es eine Vielzahl von Anbietern, welche SQLite Zugriffe bereitstellen, bspw. SQLite-Net, SQLitePCL, uvm…

Ich habe mich für SQLitePCL entschieden, da ich hier den „simplen“ SQL Syntax nutzen kann und nicht – wie bei SQLite-NET – über LINQ gehen muss.

Installieren wir uns nun also SQLitePCL. Hierbei handelt es sich um ein NuGet-Paket, welches wir in VisualStudio mit über den NuGet Paket Manager installieren können.
Hier gibt es zwei Wege:

  • GUI:
    Rechtsklick auf das Projekt -> NuGet-Pakete verwalten.
    Jetzt aktivieren wir auf der linken Seite die Option „Online“ und suchen nach SQLite-PCL. Hier installieren wir die „Portable Class Library for SQLite“.
    Sobald gefunden, installieren wir sie.
  • Kommandozeile (Nuget-Console):
    Wir öffnen die Kommandozeile und geben folgendes ein: Install-Package SQLitePCL

SQLitePCL_Nuget_Install

 

Danach installieren wir noch die benötigte Windows Library „SQLite for Windows Phone“, hierbei handelt es sich NICHT um ein NuGet-Paket sondern eine Windows SDK Extension:

SQLitePCL_SDK_Install.png

 

Nun installieren wir die Library und fügen eine/n Referenz/Verweis unserem Projekt hinzu.

Anschließend können wir endlich anfangen.

Ganz allgemein sieht ein SQLite-Befehl so aus – wie man die Verbindung (conn) aufbaut, erfahrt ihr gleich:

 
                using (var command = conn.Prepare("INSERT INTO MyTable(VALUE1) VALUES (?);"))
                {
                    command.Bind(1, MeinWert); //1-indexed parameter
                    command.Step(); //Absetzen des Befehls an die Datenbank
                }

Grundsätzlich muss man erst einmal eine Datenbank anlegen.

[spoiler title=“Datenverbindung erstellen“ style=“fancy“ anchor=“Datenbank“]

        public DatabaseConn()
        {
            SQLiteConnection conn = new SQLiteConnection("mydatabase.db");
        }

[/spoiler]
Dies legt die Datenbank in einer Datei namens „mydatabase.db“ ab oder öffnet diese.
Jetzt müssen wir – falls noch nicht geschehen – die Datenbank mit Tabellen füllen:
[spoiler title=“Tabellen-Erstellung“ style=“fancy“ anchor=“Tabelle“]

        public void LoadOrCreateDatabase()
        {
            string sql = @"CREATE TABLE IF NOT EXISTS 
                        MyTable
                        (Id INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL,
                         Header VARCHAR(255),
                         Text VARCHAR(4096),
                         Position INTEGER);";

            using (var statement = conn.Prepare(sql))
            {
                statement.Step();
            }
        }

[/spoiler]

Um Daten aus der Datenbank abzurufen, muss man erstmal differenzieren.

  • Bekommt man einen Datensatz zurück?
  • Bekommt man mehrere Datensätze zurück?

Für den ersten Fall können wir einfach eine Abfrage absetzen und die Spalten des ersten Datensatzes durchlaufen:

[spoiler title=“Select-Einzeldatensatz“ style=“fancy“ anchor=“Einzeldatensatz“]

using (var command = conn.Prepare("SELECT Id, Header, Text, Position FROM MyTable WHERE Id = ?"))
                {
                    command.Bind(1, ID); //Fill the first (one-indexed!) parameter
                    if (command.Step() == SQLiteResult.ROW || command.Step() == SQLiteResult.DONE) // Überprüfe, ob Reihe existiert oder Step ausgeführt
                    {
                        MyTableObject obj= new MyTableObject ()
                        {
                            id = (long)command["Id"],
                            header = (string)command["Header"],
                            text = (string)command["Text"],
                            position = (long)command["Position"]
                        };
                        return obj;
                    }
                }

[/spoiler]

Für den zweiten Fall müssen wir durch alle Zeilen laufen und diese Daten in unsere Objekte laden:

[spoiler title=“Select mehrerer Datensätzen“ style=“fancy“ anchor=“Mehrfachdatensätze“]

                using (var command = conn.Prepare("SELECT Id, Header, Text, Position FROM MyTable "))
                {
                    while (SQLiteResult.ROW == command.Step()) //Solange noch eine Reihe verfügbar ist, mache weiter
                    {
                        MyTableObject obj= new MyTableObject ()
                        {
                            id = (long)command["Id"],
                            header = (string)command["Header"],
                            text = (string)command["Text"],
                            position = (long)command["Position"]
                        };
                        this.list.Add(obj);
                    }
                }

[/spoiler]

Und zu guter Letzt Befehle ohne Rückgabe. Diese sind sehr einfach und lassen sich

[spoiler title=“Befehle ohne Rückgabe“ style=“fancy“ anchor=“Ohne-Rückgabe“]

                using (var command = conn.Prepare("DELETE FROM MyTable WHERE Id = ?;"))
                {
                    command.Bind(1, "MEINWERT");
                    command.Step(); //Absetzen des Befehls
                }

[/spoiler]

Das war’s. Jetzt könnt ihr eure Datenbank füllen und mit ihr arbeiten.

Release des Valve Server Tools für Windows Phone 8

Gestern war es soweit, das Valve Server Tool ging im Windows Phone Store online und kann nun auf Windows Phone 8.1 Geräten installiert werden.

„Das Valve Server Tool ist eine App zur Abfrage von Server-Daten der HLDS (Half-Life-Dedicated Servers) und SRCDS (Source Dedicated Servers), bspw. Counter-Strike:Source Servern für Game-Server Admins.
Welche Map läuft gerade auf dem Server und wie viele Spieler befinden sich auf diesem? Welche Regeln sind für diesen gerade aktiv?

Features:
* Klassische Server Information über das Valve Query Protokoll (A2S_INFO)
* Informationen über die aktuellen Spieler auf dem Server (A2S_PLAYER)
* Informationen über die, auf dem Server gültigen Regeln (A2S_RULES)

App-Sprache: Englisch“

Zur Projektseite geht’s hier entlang.

Update:
– Fixed connection issues to servers

Screenshots:
Serverdata_wvga PlayerStats_wvga Mainmenu_wvga Rules_wvga

Allgemein gültige Lösung für Zahlenketten vom Typ (x+iy) bei i <= 4

Man kam auf mich zu mit einer Knobelaufgabe der siebten Klasse und wollte von mir die Lösung für diese Frage bzw. Aufgabe wissen.
Aufgabe:
Gegeben sei eine Zahlenkette mit der „Startzahl“ x. Diese wird viermal mit der „Additionszahl“ y multipliziert.
Die Summe der Einzelergebnisse ist der Wert S.

Bsp.

math_990_2570d0efd9719cda8b93b62afdb66550

Frage:
Was ist eine Lösung für S = 100 und S = 66?

Lösungsansatz:

Zerbröseln wir einmal das ganze. Wenn man die obere Zahlenkette anschaut, so kann man sehen, dass

3(=x)   5(=x+y)    7(=x+2y)   9(=x+3y)   11(=x+4y) = S für x = 3, y = 2

x + (x+y) + (x+2y) + (x+3y) + (x+4y) = S

Nun kann man diese Funktion auch so schreiben: math_975.5_d9ea1843b3d8b23abc6979ff78d90fdf

 Durch Ausaddieren aller Werte, ergibt sich: 5x + 10y = S

Durch Umstellung ergeben sich folgende Werte: math_983_c4a9c5d5aca00bfc06d62c8d2641ac4a (1) und math_983_8ca5deb2bad2fb104d082274710eae66 (2)

Aus (2) in (1) folgt: y= math_983_6bd8c2a034b85ef49d5fed12d5ecb4e8

Aus (1) in (2) folgt: x= math_983_fd15c3a41dec083cf95a625f18aadaf9

Setzt man (1) und (2) nun wieder in die Funktion ein, so erhält man:

math_962_7b3b7172a00785dcbbbd15db86448ee2

Will man bspw. einen Wert für x wissen für die Summe 100, so nimmt man folgende Formel:
math_983_3bdbf171fee2a606058c9a1f8daaa7c4
x in (1):
math_983_ac92172b5553ddb7f0b67c5d2c789618 oder allg. math_983_6e416c20a08e1127fbb98cefed01f3ec

Die Lösungsmesse für für x und y bei S = 100 ist also:

L = {x = 10; y = 5}

Für 66 erhält man die Lösung:

L = {x = 6,6; y = 3,3}

Dies kann man jetzt noch weiterspinnen und den Parameter i ohne Zahlenwerte belassen, sodass wir eine allgemingültige Lösung für alle Zahlenketten bekommen.

Dies tun wir jetzt auch:

math_976_6943eda49eb15da2814e06b72938246c

Dies können wir nun nach y auflösen:

math_971_2ff9a81f9f4d6ac1b055cad7ad636c88(1)

math_971_a77e678ba05def2c4febe9079f424c84(2)

Nun (1) in (2) einsetzen und vice versa und man hat die Formeln für x und y unabhängig von den gegebenen Parametern y und x.

Fertig, abschließend einfach die Aufgabenwerte einsetzen.

UML Beziehungen und ihre Umsetzung im Code

Wer Software plant und entwickelt wird unweigerlich mit der Unified Modeling Language (kurz UML) in Berührung kommen.
Ich werde in  diesem Blog-Eintrag vor allem auf das Klassendiagramm, genauer auf die Beziehungen der einzelnen Klassen eingehen.

Das Klassendiagramm:

UML_ClassdiagramDas Klassendiagramm zeigt  Klassen eines Namespaces an und deren jeweilige Abhängigkeiten. Es handelt sich um eine statische Darstellung, da lediglich die Attribute und Methoden, sowie die Verbindungen der Klassen untereinander dargestellt werden. Es wird nicht gezeigt, wie diese Verbindungen stattfinden.

Darstellungselemente:

Zur Realisierung eines Klassendiagramms stehen folgende Formen und Notationen zur Verfügung

Klasse

ClassEine Klasse wird mit als Rechteck dargestellt und enthält Attribute und Methoden (Operationen). Sollte es sich um eine abstrakte Klasse handeln, so wird der Klassennamen kursiv dargestellt

Zusätzlich werden die in der Klasse enthaltenen Attribute und Operationen (bspw. Methoden) mit deren Daten- oder ggf. Rückgabetypen und Sichtbarkeiten dargestellt.

Class_ExplanationClass_AttrOperation

Zur Darstellung der Sichtbarkeit von Attributen und Funktionen bietet UML folgende Zeichen:

  • + steht für public, also eine öffentliche Funktion/ein öffentliches Attribut
  • # steht für protected, also eine geschützte Funktion/ein geschütztes Attribut
  • – steht für eine private Funktion/ein privates Attribut

Wie Anfangs erwähnt, stellt das Klassendiagramm auch die Beziehungen der Klassen untereinander dar. Ich werde in diesem Beitrag auf folgende Beziehungen eingehen und zu der jeweiligen Beziehung ein Codebeispiel (C#) geben:

  • Vererbung
  • Binäre Assoziation (zwei Klassen sind beteiligt)
  • Aggregation
  • Komposition
Vererbung:

Eine Vererbung (engl.: Inheritance) ist auch als „Ist-Ein-Beziehung“ oder „Ist-Implementiert-Als-Beziehung“ bekannt.

Als Beispiel dienen hier die Klassen Employee und Manager
Da ein Manager auch ein Mitarbeiter (Employee) ist, erbt die Klasse Manager von Employee
Dadurch werden Variablen, Felder und Methoden, welche nicht private sind in die erbende Klasse übernommen.
Achtung: Konstruktoren werden nicht vererbt und müssen daher manuell angesprochen werden:

public Manager(string _name):base(_name){ ... }

Die Umsetzung in C# würde wie folgt aussehen (Bild):

[spoiler title=“Employee-Klasse“ style=“fancy“ anchor=“BeispielVererbung“]

namespace Vererbung
{
    class Employee
    {
        static int staticID = 1;

        protected int ID = 0;
        protected string Name = "";

        public Employee(string _name)
        {
            CreateEmployee(_name);
        }

        protected void CreateEmployee(string _name)
        {
            staticID++;
            ID = staticID;
            Name = _name;
        }

        public int getID()
        {
            return ID;
        }

        public string getName()
        {
            return Name;
        }
    }
}

[/spoiler]

[spoiler title=“Manager-Klasse“ style=“fancy“]

namespace Vererbung
{
    class Manager:Employee
    {
        static int staticManagerID = 1;

        int ManagerID;

        public Manager(string _name):base(_name)
        {
            CreateManager();
        }

        private void CreateManager()
        {
            staticManagerID++;
            ManagerID = staticManagerID;
        }

        public int getManagerID()
        {
            return ManagerID;
        }
    }
}

[/spoiler]

(Binäre) assoziation:

Eine Assoziation ist eine beliebige Beziehung zwischen den Objekten von Klassen. Hier werden wir nur die binären Assoziationen (2 Klassen sind beteiligt) behandeln.

Dies ist eine gerichtete Assoziation, das bedeutet, dass Klasse 1 die Klasse 2 kennt, dagegen Klasse 2 nichts von Klasse 1 weiß. In der Beschreibung wird Beschrieben auf welche Weise die Objekte in Verbindung stehen

Links sehen wir eine bidirektionale binäre Assoziation, d.h. die Firma kennt seinen Mitarbeiter und der Mitarbeiter seine Firma.

Die Form der Assoziation sähe in der Programmierung wie folgt aus (Man beachte die Kommentierung):

[spoiler title=“Bidirektionale binäre Assoziation“ style=“fancy“ anchor=“BeispielAssoziation“]

public class Firma 
{ 
  public Mitarbeiter mitarbeiter; 
}

 public class Mitarbeiter 
{ 
  public Firma firma; 
}

public class Verzeichnis
{ 
  Mitarbeiter Mustermann = new Mitarbeiter(); 
  Firma  Musterfirma  = new Firma(); 
  Mustermann.firma  = Musterfirma;
  Musterfirma.mitarbeiter = Mustermann; 
  // Man beachte, dass die Objekte von Firma und Mitarbeiter in einer
  // weitern Klasse liegen und somit nicht voneinander abhängig sind
  // und somit weiterleben, auch wenn eines der Objekte zerstört wird
}

[/spoiler]

Aggregation:

Bei der Aggregation handelt es sich um eine spezielle Form der Assoziation. Sie ist auch als „Ganzes-Teil-Beziehung“ oder „Hat-Ein-Beziehung“ bekannt.
Darunter versteht man ein Objekt (Aggregatobjekt), welches aus verschiedenen Einzelteilen (Objekten) besteht, wobei diese nicht existenzabhängig sind (d.h. sie leben weiter, auch wenn das Aggregatobjekt zerstört wird.

Eine Beispiel für eine Aggregation wäre das Auto (als Ganzes) und ein Rad, als Teil.

[tabs]
[tab title=“Allgmeines Beispiel“]

public class Aggregatklasse
{
    ExistenzUnabhängigeKlasse objKlasse;
    public void doSomething(ExistenzUnabhängigeKlasse obj)
    {
      //Das Objekt der Klasse ExistenzUnabhängigeKlasse wird als Parameter übergeben 
      objKlasse = obj; 
	  // und ist somit noch existent wenn die Aggregatklasse zerstört wird
    }
}

[/tab]
[tab title=“Auto-Rad-Beispiel“]Wird nachgereicht…

[/tab]
[/tabs]

Komposition:

CompositionBei der Komposition handelt es sich um eine strenge Form der Aggregation. Das Kompositionsobjekt besteht, wie bei der Aggregation auch, aus mehreren Einzelteilen (Komponentenobjekte), welche jedoch im Gegensatz zur Aggregation mit der Zerstörung des Ganzen (Kompositionsobjekt) zerstört werden (Existenzabhängigkeit).
Damit ist auch die Kardinalität/Multiplizität auf Seite des Kompositionsobjekts immer 1. Das bedeutet, dass eine Komponente nur Teil eines Objekts sein kann. Somit wird sichergestellt, dass die Lebensdauer aller Objekte gleich ist. Die Kardinalität auf der Seite der Komponenten kann jedoch variable sein

Beispiel:
Ein Kunde einer Bank hat mindestens eine Anschrift und keine oder mehrere hinterlegte Bankverbindungen (kann per Rechnung zahlen).

CompositionExampleStirbt der Kunden, so wohnt er logischerweise nicht mehr und ist ebenso wenig ein Kunde der Bank. Seine Anschrift(en), sowie seine Bankverbindung(en) werden also zerstört

Die Umsetzung im Code würde wie folgt aussehen:

[spoiler title=“Codebeispiel Komposition“ style=“fancy“ anchor=“BeispielKomposition“]

public class CompositionClass
{
    SomeUtilityClass objSC = new SomeUtilityClass(); //Das Objekt der Klasse
    // existiert lediglich in der CompositionClass und wird mit dem Objekt der
    // CompositionClass vernichtet

    public void doSomething()
    {
        objSC.someMethod();
    }
}

[/spoiler]

Die ersten Wochen im nebenberuflichen Studium an der FOM

Bereits nach meinem Abitur habe ich mich mit dem Thema Studium beschäftigt, wollte zu diesem Zeitpunkt jedoch kein Studium beginnen, da ich erst einmal ein wenig flüssig werden wollte und zudem auch (ich bin ehrlich) keine Lust auf noch mehr „Schule“ hatte.

Also entschied ich mich für eine Ausbildung als Fachinformatiker, was im Nachhinein betrachtet auch die richtige Entscheidung war. Ich konnte während meiner Ausbildung einige Erfahrung im ERP-Umfeld (Dynamics NAV) sammeln und erhielt auch erste Einblicke in den wirklichen Ablauf eines Unternehmens.

Schon während meiner Ausbildung festigte sich mein Entschluss, dass ich nach meiner Ausbildung studieren möchte und so machte ich mir erste Gedanken zu diesem Thema.
Ich zuerst mit dem Gedanken ein Vollzeitstudium zu absolvieren und als Minijobber weiterhin beim ACE beschäftigt zu bleiben oder mich für ein Fernstudium einzuschreiben (wobei ich diese Alternative nicht favorisierte)

Da ich jedoch als Ersatz für einen in altersbedingt (Rente) ausscheidenden Kollegen ausgebildet wurde, war mein Ausbilder von dieser Idee nicht begeistert und schlug mir ein nebenberufliches Studium an der FOM in Stuttgart vor.

Die Webseite machte einen guten Eindruck, das ZEIT-Ranking der Hochschule war gut und auch die Erfahrungsberichte machte einen guten Eindruck. So besuchten mein Ausbilder und ich einen Info-Abend an der FOM und waren überzeugt.

So schrieb ich mich an der FOM für das Wintersemester 2014 im Fach Wirtschaftsinformatik (B.Sc.) ein und am 5. September 2014 startete offiziell das Semester (nach der Eröffnungsveranstaltung am 03.09.13) mit der ersten Vorlesung.

Im ersten Semester haben wir übrigens folgende Studienfächer:

  • Management Basics
  • E-Business
  • Prozedurale Programmierung
  • IT-Basics

WIESO WIRTSCHAFTSINFORMATIK?

Während meiner Ausbildung wurden immer wieder Änderungen am unserem ERP-System vorgenommen – Viele davon im Bereich der Buchhaltung. Programmiertechnisch verstand ich die Änderungen, jedoch fehlte mir an vielen Stellen der betriebswirtschaftliche Hintergrund. Somit wollte ich dieses Wissen erweitern ohne mich jedoch komplett von der Informatik zu entfernen.

Die Wirtschaftsinformatik war somit der perfekte Zwischenweg um dies zu bewerkstelligen

ABLAUF des studiums

Bei dem Studium an der FOM handelt es sich um ein Präsenzstudium. Vor Beginn des Semesters wurden die Skripte über das Onlineportal (Online Campus) verteilt. Diese sollte man ausdrucken und während der Vorlesung bereithalten, sodass man sich ggf. auf einer Seite Notizen machen kann

Die Benotung der einzelnen Fächer erfolgt durch s.g. Scientific Abstracts und einer Klausur. Bei dem Scientific Abstract handelt es sich um eine kurze prägnante Zusammenfassung (max. 2 Seiten) zu einem bestimmten Thema. Während des Semesters werden 4-5 Themen genannt, zu denen man sich vorbereiten sollte (Hausarbeit). Zu einem genannten Termin wird dann eines dieser Themen gewählt und es wird unter Prüfungsbedingungen eine Zusammenfassung zu dem Thema geschrieben.

Diese wird mit 20% gewichtet. Zudem schreibt man Klausur, welche mit 80% gewichtet wird

DIe erste vorlesung

Unsere erste Vorlesung war im Fach Management Basics. Hier wurden uns bisher vor allem betriebswirtschaftliche Grundlagen vermittelt (bspw. Unternehmensformen, SWOT-Analyse, Target Costing…), auf welche in späteren Modulen aufgebaut wird.

Zu Beginn nahm ich zu den Vorlesungen im Fach Management Basics mein Tablet mit Tastatur und das Skript in digitaler Form mit. In dem PDF habe ich dann digitale Notizen hinzugefügt.

Mittlerweile habe ich das Skript jedoch gedruckt, denn es ist wesentlich schneller und einfacher die Notizen handschriftlich auf das Skript zu schreiben.

Man sollte sich auch nicht der Illusion hingeben, dass es so wie bisher in der Schule läuft. Der Prof wird euch nicht sagen, was ihr aufschreiben sollt und was nicht. Ihr müsst selbst die wichtigen Dinge selbst filtern und zu Papier bringen.

© 2018 Abou Chleih. Alle Rechte vorbehalten.

Thema von Anders Norén.