GitLab konfigurieren

Für die Konfiguration des GitLab mit dem Omnibus-Package ist nur eine Datei notwendig, diese ist die “/etc/gitlab/gitlab.rb”. Ein Beispiel:

# URL die im Browser eingegeben wird. (Es scheint so, das am Ende kein / stehen darf)
external_url "https://gitlab.example.com"
# Ist notwendig, damit die richtige URL bei den Projekten steht. Gerade bei Sub-Sub-Domains, z.B: gitlab.mydomain.example.com.
gitlab_rails["gitlab_host"] = 'gitlab.example.com'
# EMail-Adresse die als Absender eingetragen wird
gitlab_railse["gitlab_email_from"] = 'gitlab@example.com'

Nach jeder Änderung in der Konfiguration muss gitlab rekonfiguriert werden, das macht man mit folgenden Befehl:

gitlab-ctl reconfigure

Wenn nginx nicht starten kann, weil ein anderer Webserver schon läuft, dann kann man das wie folgt lösen. Zuerst muss man nginx umkonfigurieren, damit dieser auf einen anderen Port lauscht. In der Datei “/etc/gitlab/gitlab.rb” die external_url anpassen:

external_url "http://gitlab.example.com:880"

Da hier ein interne Verbindung benutzt wird, um von dem einen Webserver auf den anderen zu kommen, reicht hier http völlig aus. Das “:880″ definiert den Port an dem nginx lauschen soll. Sollte nach dem Re-konfigurieren von gitlab, nginx noch nicht am angegeben Port lauschen, was mit nachfolgenden Befehl nachgeprüft werden kann:

netstat -pant

Dann sollte man nginx per Hand stoppen und starten:

gitlab-ctl stop nginx
gitlab-ctl start nginx

Nun muss der andere Webserver noch als Proxy eingerichtet werden. Beim Apache (ab Version 2.0) müssen zuerst die Proxy-Module aktiviert werden:

a2enmod proxy
a2enmod proxy_http

In der VHost-Konfiguration zum Gitlab-Server sollte dann ungefähr so ausschauen:

# unverschlüsselte Verbindung
<VirtualHost w.x.y.z:80>
  ServerName gitlab.example.com
  ServerAdmin hostmaster@example.com
  # Umleiten auf HTTPS
  <IfModule mod_rewrite.c>
    RewriteEngine On
    RewriteCond %{HTTPS} off
    RewriteRule ^/(.*) https://gitlab.example.com/$1
  </IfModule>
  Redirect / https://gitlab.exmaple.com/
</VirtualHost>
# SSL Konfiguration
<VirtualHost w.x.y.z:443>
  ServerName gitlab.example.com
  ServerAdmin hostmaster@example.com
  SSLEngine On
  SSLHonorChipherOrder On
  SSLCipherSuite ECDHE-RSA-AES128-SHA256:AES128-GCM-SHA256:RC4:HIGH:!MD5:!aNULL:!EDH
  SSLVerifyDepth 10
  SSLCertificateFile /../...pem
  SSLCertificateKeyFile /../...key
  SSLCertificateKeyFile /../...crt
  SSLCertificateKeyFile /../...csr
  ...
  # Internes weiterleiten an den nginx
  <IfModule mod_proxy.c>
    ProxyVia On
    ProxyRequests Off
    ProxyPass / http://127.0.0.1:880/
    ProxyPassReverse / http://127.0.0.1:880/
    ProxyPreserveHost Off
    <Proxy *>
      Options FollowSymLinks MultiViews
      AllowOverride All
      Order allow,deny
      allow from all
    </Proxy>
  </IfModule>
</VirtualHost>

Und dann noch den Apache die Konfiguration erneut einlesen lassen, mit nachfolgenden Befehl:

service apache2 reload #oder restart wenn man möchte

Nun sollte man über den Zugriff “https://gitlab.example.com” auf die GitLab anmelde Webseite kommen. Und bei den Projekten, sollten auch die richtigen URL’s erscheinen.

Weitere Informationen zu Einstellungen von GitLab findet man hier.

Veröffentlicht unter Programmieren | Verschlagwortet mit , , , | Hinterlasse einen Kommentar

seed auf MS SQL Tabellen ermitteln bzw. setzen

Um den SEED auf einer MS SQL Server Tabelle zu setzen, sind folgende Befehle notwendig:

dbcc checkident (<tblname>, reseed, <newMaxSeed>)

Ein Beispiel:

-- create table tblMy (nKey identity(1, 1), ...)
declare @maxKey int
select @maxKey = max(nKey) from tblMy
dbcc checkident (tblMy, reseed, @maxKey)

Hier noch ein Befehl, mit dem man alle aktuellen Seeds der vorhanden Tabellen sieht, die auch eine Identity-Spalte besitzten:

select Seed            = ident_seed(TABLE_NAME)
     , Increment       = ident_incr(TABLE_NAME)
     , CurrentIdentity = ident_current(TABLE_NAME)
     , Table           = TABLE_NAME
from   INFORMATION_SCHEMA.TABLES
where  objectproperty(object_id(TABLE_NAME), 'TableHasIdentity') = 1
and    TABLE_TYPE = N'BASE TABLE'
Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

Debian: Verzeichnis packen und per Mail versenden

Zuerst das Packen der Dateien:

tar cfvz zieldatei.tar.gz Quellverzeichnis/Quelldateie(n)

dann die Mail verschicken:

echo "Mail Inhalt" | mail -s "Betreff" -a zieldatei.tar.gz sender@domain.tld
mail -s "Betreff" -a zieldatei.tar.gz sender@domain.tld < echo MailInhalt.txt

 

Veröffentlicht unter Linux/Unix | Verschlagwortet mit , , | Hinterlasse einen Kommentar

Tabelle aus MS SQL Server exportieren und wieder einspielen

Um eine Tabelle komplett aus dem MS SQL Server zu exportieren benutzt man typischer Weise den BCP Befehl. Zum exportieren benutzt man folgenden Befehl:

bcp <db>.<schema>.<table> out <table-file> -S <sql-svr> -T -c

Um diese Tabelle wieder am anderen Server einzubuchen, sollte diese Tabelle am besten leer sein. Das Eintragen funktioniert dann mit folgenden Befehl:

bcp <db>.<schema>.<table> in <table-file> -S <sql-svr> -T -c

Die Bedeutung der Parameter am BCP-Befehl:

  • out (in): der Weg den die Daten gehen, heraus aus der DB in die Datei (von der Datei in die DB)
  • -S <sql-svr>: Darüber wird der MS-SQL-Server angegeben, mit dem gearbeitet wird
  • -T: Gesicherte Verbindung, wenn nicht möglich kann über “-U/-P” ein Benutzer und das Password angegeben werden
  • -c: definiert die Zeichentypen, wenn dies nicht angegeben wird, muss für jede Spalte die Definition einzeln angegeben werden

Für weitere Hilfe, kann man noch hier bei Microsoft direkt nachschauen für weitere Parameter.

Veröffentlicht unter SQL | Hinterlasse einen Kommentar

Git GUI unter Linux an GitLab Server mit PuTTY-Key

Nach der Umstellung auf LInux System, benötigte ich meinen vorhanden PuTTY-Schlüssel als OpenSSH Schlüssel im Linux System. Für die Wandlung gibt es unter linux puttygen, was entweder einzeln oder im Packet putty-tools installiert wird. Zum Wandeln wird folgender Befehl benutzt:

puttygen <keyfile> -O  private-openssh -o <output>

In <keyfile-PuTTY> wird der Putty-Schlüssel angegeben und bei <output> wird die Ausgabedatei angegeben, welche auch direkt die Datei “~/.ssh/id_rsa” sein kann.

Um den Public-Key zu ermitteln, wird folgender Befehl benutzt:

ssh-keygen -f <source-private-key> -y > <output>

Hier wird bei <source-private-key> der OpenSSH-Private-Key benötigt, und bei Output der Ziel des Public-Keys definiert, z.B: “~/.ssh/id_rsa.pub”.

Damit dann meine gewählte Git-GUI, hab mich für GitEye entschieden, auch noch richtig funktionierte musste unter “Window -> Prfeferences -> General -> Nework Connections -> SSH2 -> Private keys: der id_rsa an den Anfang geschoben werden.

Veröffentlicht unter Linux/Unix | Hinterlasse einen Kommentar

Linux Desktop Screenshots und Video-Aufzeichnung

Um unter Linux einen Screenshot vom Desktop oder nur eines Ausschnitts zu erzeugen, gibt es die Software Shutter. Nach dem Start dieser Software, kann damit genauso gearbeitet werden wie mit dem Snipping-Tool von Windows 8.

Zu Aufzeichnung eines Desktop-Videos, kann unter Gnome zum einem die Tastenkombination “Strg + Alt + Umschalt + R” benutzt werden. Nach dem Starten erscheint oben rechts ein roter Punkt, der darstellen soll, dass die Aufnahme läuft. Das Video wird in den Benutzerverzeichnis im Ordner Videos abgelegt.

Des weiteren gibt es die Software SimpleScreenRecorder, welche eine Hülle an möglichen Einstellungen besitzt (die nicht angepasst werden müssen, aber können). Mit dieser können auch nur feste Ausschnitte bzw. der Maus folgende Ausschnitte aufzeichnet werden und nicht immer der ganze Desktop.

Veröffentlicht unter Linux/Unix | Hinterlasse einen Kommentar

Windows 8 Energiesparmodus

Da ich immer wieder Probleme mit automatischen Aufwachen aus dem Energiesparmodus in Windows 8 hatte, hab ich mich im Internet etwas umgeschaut und bin auf folgenden Befehl gestoßen:

powercfg -devicequery wake_armed

Mit diesen, werden alle Geräte aufgelistet, die den Rechner aus den Energiesparmodus aufwecken dürfen. Und mit nachfolgenden Befehl, können einzelne Geräte entfernt werden:

powercfg -devicedisablewake [device_name]

(device_name, durch den Namen des zu entfernenden Gerät ersetzen. Vorsicht, wenn der Gerätename Leerzeichen beinhaltet, muss der Namen mit “” umschlossen werden)

Veröffentlicht unter Windows | Verschlagwortet mit , | Hinterlasse einen Kommentar

.Net und WebRequest mit Authentifizerung

WebRequest in C# abzusetzten ist mit den Bibliotheken recht einfach geworden. Aber wenn es dann mal mehr wird, als nur ein einfacher Download wird es schon wieder schwieriger. Daher hier eine kurze Anleitung, wie so ein Request bearbeitet wird.

Zuerst muss ein WebRequest erstellt werden:

var webReq = (HttpWebRequest)HttpWebRequest.Create("http://example.com/");

Dann muss unterschieden werden, ob es ein laden einer Website ist, oder ob senden von Daten an die Website ist. Bei laden einer Website wird häufig die GET-Methode verwendet, siehe hier:

webReq.Method = "GET"; // Ein einfache Get-Befehl, mit Parameter in der URL ala: example.com?param1=val1&param2=val2
// Request abschicken und Antwort auswerten 
try {
  // Beim GetResponse() fliegen die Fehlermeldungen, die der Server zurückgibt, wie 404 (Datei nicht gefunden) oder 401 (Nicht Authentifiziert)
  var webRes = (HttpWebResponse)webReq.GetResponse();
  // und nun den Stream lesen
  using (var streamer = webReq.GetResponseStream()) {
    // Hier kann man nun anhand von webRes.ContentType unterschiedlich die Daten verarbeitetn, z.B.: bei "text/xml" mit einem (new XmlDocument()).Load(streamer); alles in ein Xml-Objekt packen
  }
}
catch (WebException exc) {
  // Exceptions verarbeiten
}

Für die einfache übermittlung von Variablen mit der POST-Methode, hier noch ein Code-Schnipsel:

webReq.Method = "POST";
webReq.ContentType = "application/x-www-form-urlencoded";
// Variablen zusammenbauen und in Byte-Array wandeln um es auf den Stream schreiben zu können
var postData = "variable1=val1&variable2=val2";
var postBytes = Encoding.UTF8.GetBytes(postData);
// Länge der Daten mitgeben und diese nun auf den Stream schreiben
webReq.ContentLength = postBytes.Length;
var stream = webReq.GetRequestStream();
stream.Write(bytes, 0, bytes.Length);
// Request abschicken und Antwort auswerten (wie bei GET-Methode)
try {
  // Beim GetResponse() fliegen die Fehlermeldungen, die der Server zurückgibt, wie 404 (Datei nicht gefunden) oder 401 (Nicht Authentifiziert)
  var webRes = (HttpWebResponse)webReq.GetResponse();
  // und nun den Stream lesen
  using (var streamer = webReq.GetResponseStream()) {
    // Hier kann man nun anhand von webRes.ContentType unterschiedlich die Daten verarbeitetn, z.B.: bei "text/xml" mit einem (new XmlDocument()).Load(streamer); alles in ein Xml-Objekt packen
  }
}
catch (WebException exc) {
  // Exceptions verarbeiten
}

Dann gibt es aber noch die Probleme mit den Anmeldungen an dem WebServer, die mit folgenden Quellcode-Stücken gelöst werden können:

// Um die aktuelle Anmeldung zu benutzen (Häufig im Intranet möglich)
request.UseDefaultCredentials = true;
// Für eine explizite Netzwerkidentifikation (Via Domain)
request.Credentials = new NetworkCredential("username", "password");
// Für eine HTTP-Authentifizierung (Wird häufig via .htaccess parametriert)
var auth = Encoding.UTF8.GetBytes("user:password");
request.Headers["Authorization"] = "Basic " + Convert.ToBase64String(auth);
// Und ein Übel gibt es noch, wenn man einen Server besitzt der zwar mit SSL-Zertifikaten ausgestattet ist, aber
// keine Root-Zertifikate besitzt, kann mit nachfolgenden Code, mit diesen Server trotzdem reden:
ServicePointManager.ServerCertificateValidationCallback = delegate { return true; };
// Wobei hier zu bedenken ist, dass nun alle Zertifikate angenommen werden, man könnte hier noch eine passende Prüfung einbauen

Wenn Dateien an einen Website hochgeladen werden sollen, wird das ganze etwas schwieriger, daher habe ich dafür eine Klasse gebaut, die man unter nachfolgenden Link herunterladen kann: HttpFileUploader.
Hier noch eine Beispiel-Verwendung:

// Objekt erstellen
var fileUploader = new HttpFileUploader("http://example.com/upload");
// Parameter setzten
fileUploader.SetParam("LastModifiedSource", DateTime.Now.ToString("yyyy-MM-dd hh:mm:ss"));
fileUploader.SetParam("Name", "ExampleName");
fileUploader.SetParam("Designation", "ExampleDesignation");
// XML-Datei setzten
var xmlfile = System.Text.Encoding.Unicode.GetBytes(xmlString);
fileUploader.SetFile("xmlfile", "xmlfile.xml", xmlfile, "text/xml");
// Bild setzen
fileUploader.SetFile("picture", "picture.png", pictureBytes, "image/png");
// Upload durchfuehren
var ret = fileUploader.SendRequest();
Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar

WordPress TinyMCE wieder aktivieren

Seit dem ich Markdown ausprobiert hatte, funktionierte mein TinyMCE-Editor nicht mehr. Nach langen suchen hab ich auch nicht wirklich was gefunden, immer nur Links auf TinyMCE Advanced Plugin.

Daher dachte ich, das ich mir das alte Plugin wieder suchen müsste, diese installieren und dann durch erneutes deaktivieren der TinyMCE wieder erscheint. Dabei bin ich dann aber auf des Rätsels Lösung gestoßen.

Ich musste das alte Plugin nicht installieren, sondern in meinen Profil, ist die erste Option wenn diese gesetzt ist, zum deaktivieren des TinyMCE vorhanden. Nach dem ich den Haken wieder entfernt habe, erscheint nun endlich der TinyMCE-Editor weider *freu*.

Veröffentlicht unter Allgemein | 1 Kommentar

Umbau des Blogs

Guten Tag Leser

Der Blog wird aktuell umgebaut.

Zuerst wird ein Strukturierender Umbau durchgeführt. Alles was als KnowHow gehandelt wird, wird ab sofort in die Wissensdatenbank eingetragen, damit die Artikel einfach zu finden sind. In den Standard-Blog kommen dann noch Eintrage die mehr an Meldungen erinnern.

Nachfolgend wird noch ein neuer Style auf HTML5 und CSS3 kommen wird, da dieser nicht gekauft wird, sondern von mir selbst gebaut wird, dauert dies noch etwas bis er komplett funktionstüchtig ist und für alle aktiviert wird.

Mfg MDN

Veröffentlicht unter Allgemein | Hinterlasse einen Kommentar