Kategorien
IT SQL

Microsoft SQL Server Management Studio – verbleibende Datenbank-Restore-Dauer anzeigen

Vielleicht habt ihr auch schon mal in einem Microsoft SQL Server einen Restore einer Datenbank durchgeführt und wolltet wissen, wie weit der Restore nach einigen Minuten/Stunden schon gekommen ist und wann der Restore ungefähr beendet sein wird.

Wird der Restore via „Management Studio“-GUI durchgeührt (Datenbank-Kontextmenü -> Tasks -> Restore), dann habt ihr im Restore-Dialog zumindest eine ungefähre Prozent-Anzeige. In der 2012er-Version wird diese oben rechts angezeigt:

Die Prozent-Anzeige erscheint aber erst nach einem Weilchen und wenn man den Restore via SQL-Skript gestartet hat und dabei „STATS“ nicht (oder mit einem ungünstigen Wert) verwendet hat, weiss man auch nicht bei wieviel Prozent der Restore aktuell steht und wie lange er noch dauert. Häufig bleibt die Prozentzahl auch lange unverändert und man ist sich nicht sicher, ob der Restore noch läuft oder sich aufgehängt hat.

Zum Glück gibt es jedoch eine Möglichkeit mit einem SQL-Befehl den aktuellen Fortschritt und die geschätzte Endzeit zu erhalten – egal ob  der Backup-Job via GUI, Skript oder sogar von einer anderen Maschine gestartet wurde. Voraussetzung ist ein MSSQL Server der Dynamic Management Views (DMVs) unterstützt, also ab MSSQL 2005. Ist das gegeben kann man folgenden Befehl als Query absetzen (es muss keine Datenbank dazu vorselektiert werden):

SELECT session_id as SPID, command, a.text AS Query, start_time, percent_complete, dateadd(second,estimated_completion_time/1000, getdate()) as estimated_completion_time
FROM sys.dm_exec_requests r CROSS APPLY sys.dm_exec_sql_text(r.sql_handle) a
WHERE r.command in ('BACKUP DATABASE','RESTORE DATABASE')

Das Resultat sieht dann zum Beispiel wie folgt aus (unterer Bereich, Spalten percent_complete und estimated_completion_time):

Im Beispiel sieht man also, dass bereits 96.16975 % des Restores durchlaufen ist und der Restore um 12:38 Uhr, des 7. Dezember 2016, fertig sein sollte – nach ungefähr 19 Stunden Laufzeit. Praktisch oder?

Gefunden auf: https://www.mssqltips.com/sqlservertip/2343/how-to-monitor-backup-and-restore-progress-in-sql-server/

Kategorien
IT personal Unity

Unity 5 Spiel-Engine

Letzte Woche wurde die neueste Version, nämlich Nummer 5, der Unity Spiel-Engine offiziell veröffentlicht. Ausserdem wurde in der selben Woche das Lizenzierungsmodel der Unreal Engine 4 angepasst, so dass diese nun grundsätzlich von jedem verwendet werden kann (erst ab einem Umsatz von 3000 Dollar pro Quartal, muss man selber etwas bezahlen). Auch Valve hat die Veröffentlichung der „Source 2“-Engine angekündigt, welche voraussichtlich ebenfalls in einer freien Version verfügbar sein soll.

Unity gibt es schon länger gratis in einer Einsteiger-Version, mit der man aber schon sehr viel machen kann. Möchte man aber z.B. einen Asset Server verwenden (mit Versionsverwaltung) oder einen eigenen Splash-Screen vor dem Spiel präsentieren (und noch einige andere Features mehr, siehe Unity-Website), dann muss man die Pro-Lizenz erwerben, welche mit 75$ im Monat immer noch sehr bezahlbar ist. Für die Möglichkeit das Entwickelte Produkt auf iOS oder Android zu deployen, wird jedoch nochmals (je) 1500$ verlangt oder je 75$ zusätzlich pro Monat.

Aus Neugierde habe ich mich einige Stunden mit der Unity-Engine auseinander gesetzt und auch einige der Einsteiger-Tutorials bereits umgesetzt. Die Engine hat meiner Einschätzung nach eine gute Lernkurve, man erreicht schon nach kurzer Zeit erste Erfolgserlebnisse die einen anspornen sich tiefer mit den weiteren Möglichkeiten zu beschäftigen. Der Editor, mit welchem die Szenen, Animationen und Objekte bearbeitet werden können wirkt sehr aufgeräumt und kann intuitiv bedient werden – man fühlt sich schnell zu Hause. Für einen C#-Entwickler ist es zudem praktisch, dass als Script-Sprache C# (Mono via einer mitgelieferten MonoDevelop-Version) verwendet werden kann. Unreal 4 mit C++ hat mich da schon etwas abgeschreckt 🙂

Nach wenigen Stunden hatte ich bereits ein kleines, erstes Spiel fertig (nach Tutorial, Objekte/Texturen wurden als Asset bereitgestellt):

Wer selber mit Unity loslegen will, der sollte am besten mit den Tutorials auf der offiziellen Unity-Webseite beginnen:

Viel Spass!

Kategorien
Android

Qooli Timelapse Calculator

Abgekürzt QTLC. Eine Anwendung für Google’s Android-Plattform mit welcher man bequem auf seinem Handy Timelapse-Berechnungen durchführen kann.

Qooli Timelapse Calculator LogoMan kann zum Beispiel ausrechnen, wie lange man bei eingem gewissen Shutter-Intervall und FPS (im resultierenden) Aufnahmen machen muss. Man kann aber auch umgekehrt ausrechnen wieviel Filmdauer man auf Grund einer Aufnahmezeit, dem Intervall und den FPS erreicht hat.

Die Anwendung wird ständig weiter ausgebaut und mit weiteren Features versehen, so ist z.B. eine Timerlapse-Stoppuhr mit Erinnerungsfunktion geplant oder der zu erwartende Speicherplatz verbrauch für die Aufnahmen während der Aufnahme-Session.

Die Anwendung kann im Play Store heruntergeladen werden:

Get it on Google Play

Direkt den QR-Code scannen um die App-Store-Seite der Anwendung auf dem Handy zu öffnen… wo man sie dann kaufen kann 🙂

QR-Code von QTLC
QR-Code von QTLC: mit einem QR-Code-Scanner einlesen um die App-Store-Seite zu öffnen
Kategorien
IT

MySQL- und Website-Backup periodisch erstellen

Vor einigen Tagen konnte ich einen Punkt von meiner Aufgabenliste streichen, welchen ich schon längere Zeit offen hatte und eigentlich schon lange einmal hätte umsetzen wollen und sollen: das Einrichten eines Backups für meine Webseite.

Bisher machte ich nur sporadisch entweder manuelle Backups der Daten der Webverzeichnisse und der dazugehörigen MySQL-Datenbanken oder ich habe bei meinem VPS-Provider ein Backup für die ganze Maschine durchgeführt – beides nicht gerade sehr sexy, das muss besser und eleganter gelöst werden, dachte ich mir.

Als erstes schrieb ich ein Shell-Skript, welches mir alle Datenbanken (ausser den System-Datenbanken) in Archiv-Dateien exportiert (alle Pfade und Benutzerangaben wurden durch Beispieldaten ersetzt):

#!/bin/bash

BACKUP_DATE="$(date +%Y-%m-%d)"
DB_BACKUP_ROOT="/zielpfad/zum/backup/mysql"
DB_BACKUP="$DB_BACKUP_ROOT$BACKUP_DATE"
DB_USER="Datenbank-Benutzer"
DB_PASSWD="Datenbank-Kennwort"
HN=`hostname | awk -F. '{print $1}'`
# Create the backup directory
mkdir -p $DB_BACKUP

# Remove backups older than 30 days
find $DB_BACKUP_ROOT -maxdepth 1 -type d -mtime +30 -exec rm -rf {} \;

# Backup each database on the system using username and password
for db in $(mysql --user=$DB_USER --password=$DB_PASSWD -e 'show databases' -s --skip-column-names|grep -vi information_schema);
do
  BACKUP_FILE_PATH="$DB_BACKUP/mysqldump-$HN-$db-$BACKUP_DATE.gz"
  mysqldump --user=$DB_USER --password=$DB_PASSWD --opt $db | gzip > $BACKUP_FILE_PATH;
  # Set desired permissions
  chmod -R 600 $BACKUP_FILE_PATH
done

Das obenstehende Skript macht folgendes:

  • Zuerst setze ich einige Variablen, wie das Zielverzeichnis für die Backup-Dateien. Ich lese das aktuelle Datum aus und speichere es in einer Variable und benutze dies, um für die täglichen Backups jeweils ein neues Zielverzeichnis innerhalb des festgelegten „DB_BACKUP_ROOT“ zu erstellen.
  • Danach setze ich die MySQL-Zugangsdaten und ermittle den Host-Namen des Rechners, um diesen später auch zum Dateipfad hinzuzufügen.
  • Mittels des „find“-Befehls ermittle ich alle Backups, welche älter als 30 Tage sind und lösche diese.
  • Danach iteriere ich in einer Schleife über alle relevanten Datenbanken und speichere diese mittels „mysqldump“ an den gewünschten Zielort, dabei pipe ich das Resultat von „mysqldump“ zuvor noch an „gzip“ und sorge damit, dass ich eine Archivdatei erhalte.
  • Zum Schluss ändere ich mittels „chmod -R 600 …“ noch die Dateirechte der zuvor erstellten Backup-Datei, so dass nur noch der Besitzer der Datei diese lesen und ändern kann.

Nun habe ich die Datenbank gesichert. Mittels eines weiteren Shells-Skripts sichere ich nun noch die Dateien der einzelnen Webseiten:

#!/bin/bash

WWW_ROOT="/var/wwwdir/websites/"
WWW_BACKUP_ROOT="/zielpfad/zum/backup/www"
WWW_BACKUP="$WWW_BACKUP_ROOT`date +%Y-%m-%d`"
HN=`hostname | awk -F. '{print $1}'`
# Create the backup directory
mkdir -p $WWW_BACKUP

# Remove backups older than 30 days
find $WWW_BACKUP_ROOT -maxdepth 1 -type d -mtime +30 -exec rm -rf {} \;

# get arguments
while [ "$1" != "" ]; do
  case $1 in
    -s | --site )     shift
                      site=$1
                      ;;
    * )               echo "Unknown argument $1."
                      exit 1
  esac
  shift
done

# Backup website
if [ "$site" != "" ]; then
  BACKUP_PATH="$WWW_BACKUP/www-$HN-$site-$(date +%Y-%m-%d).tar.gz"
  WWW_PATH="$WWW_ROOT$site"
  echo "Backing up site $WWW_PATH to $BACKUP_PATH" 
  cd $WWW_ROOT
  tar -czf $BACKUP_PATH $site
  chmod -R 600 $BACKUP_PATH
else
  echo "You need to specifiy a site to backup with the -s argument."
  exit 1
fi

Dieses Skript macht folgendes:

  • Als erstes setze ich wieder einige Variablen. Das Quellverzeichnis der Webseiten-Daten wird angegeben (WWW_ROOT) und das (Wurzel-)Zielverzeichnis für die Backup-Daten wird festgelegt (WWW_BACKUP_ROOT). Ausserdem lege ich den Ordernnamen für die täglichen Backups fest (WWW_BACKUP), dazu verwende ich wie schon beim MySQL-Backup das „date“-Befehl.
  • Mittels mkdir -p $WWW_BACKUP wird der tägliche Backup-Ziel-Ordner erstellt, es sei denn er ist schon vorhanden (dazu ist der „-p“-Parameter da).
  • Erneut suche ich mittels „find“ alle Backup-Dateien, welche älter sind als 30 Tage und lösche diese.
  • Danach kommt eine „while“-Schleife, mit der ich die Argumente, welche dem Skript übergeben wurden auslese, dies ist nötig, da ich das Skript später mittels Cron-Job aufrufen möchte und jeweils die Quell-Webseite mittels eines Parameters angeben möchte. Wenn keine Website als Argument übergeben oder falls ein unbekanntes Argument übergeben wurde, wird das Skript beendet (exit 1).
  • Danach wird die eigentliche Backup-Datei erstellt. Dazu wird der Zielpfad der Archivdatei zusammengesetzt (BACKUP_PATH) und dann mittels dem „tar“-Befehl das Backup erstellt und gepackt.
  • Am Ende passe ich wieder die Dateirechte mittels „chmod“ an, so dass nur der Besitzer die Datei lesen und ändern kann.

Nun haben wir zwei Skripts, welche die für mich relevanten Komponenten der Webseiten sichern können, jedoch müssten diese immernoch manuell ausgeführt werden. Damit automatisch täglich die Backups erstellt werden, richtete ich unter einem Account einige Cronjobs (Befehl: crontab -e) ein, welche die (ausführbaren) Skripte einmal am Tag laufen lassen:

# Daily website backup
15 2 * * * /usr/local/bin/mysql_backup.sh >/dev/null 2>&1
15 2 * * * /usr/local/bin/www_backup.sh -s website_dir_1 >/dev/null 2>&1
15 2 * * * /usr/local/bin/www_backup.sh -s website_dir_2 >/dev/null 2>&1
15 2 * * * /usr/local/bin/www_backup.sh -s website_dir_3 >/dev/null 2>&1
45 4 * * * /usr/local/bin/copy_backup_to_different_server.sh >/dev/null 2>&1

Die Backups werden mit dieser Konfiguration also immer um 2:15 Uhr durchgeführt. „/dev/null 2>&1“ bewirkt, dass die Ausgaben unterdrückt werden, sie landen im Nirvana.

In der letzten Zeile der obenstehenden Crontab seht ihr, dass noch ein weiteres Skript „copy_backup_to_different_server.sh“ zu einem späteren Zeitpunkt aufgerufen wird.
Da die Daten bisher nur lokal auf dem Server gesichert werden, nützen sie mir nichts, falls es zu einem generellen Datenverlust auf dem Server käme. Zur Sicherheit kopiere ich also die Backup-Archive noch an einen weiteren Ort, auf einen anderen Server.

Das  Skript ist wie folgt aufgebaut:

  • #!/bin/bash
    
    rsync -rlthvz --delete --owner=1111 --group=333 -e '/usr/bin/ssh -i /home/userXy/.ssh/id_rsa' /zielpfad/zum/backup/ user@remote.server.com:/volumeXy/home/userMn/MyFiles/Backup/websites<span id="mce_marker" data-mce-type="bookmark" data-mce-fragment="1">​</span>

    Das Skript kopiert via RSYNC alle neuen Dateien von „/zielpfad/zum/backup“ auf den Server „remote.server.com“ in den Pfad „/volumeXy/home/userMn/MyFiles/Backup/websites“. Die Verbindung wird im Beispiel mit dem Benutzer „user“ durchgeführt.

  • Die Verbindung geschieht durch den SSH-Aufruf innerhalb des RSYNC-Befehls über eine verschlüsselte SSH-Verbindung.
  • „–delete“ bewirkt, dass im Ziel die Dateien gelöscht werden, welche nicht mehr in der Quelle vorhanden sind.
  • Mittels „–owner=…“ und „–group=…“ setze ich den Besitzer und die Gruppe der neuen Dateien und Ordner auf dem Zielsystem, da diese nicht mit denen auf dem Quellsystem identisch sind.

Damit RSYNC via SSH auch ohne Kennwort-Eingabe funktioniert, muss man natürlich zuerst ein Schlüssel-Paar (öffentlich/privat) erzeugen (sofern man noch keines hat) und den öffentlichen Schlüssel auf dem Zielsystem in den „Authorized Keys“ eintragen. Hier findet ihr eine Anleitung dazu: http://www.thegeekstuff.com/2008/11/3-steps-to-perform-ssh-login-without-password-using-ssh-keygen-ssh-copy-id/

Nun ist das Backup also eingerichtet. Es sichert täglich automatisch die Websites mitsamt der Datenbank und kopiert diese Dateien zur Sicherheit auch noch auf einen anderen Server.

Kategorien
IT

Feeds parsen und schreiben mit Python

Ich hatte letzthin das Problem, dass ich auf meiner neuen Fotografie-Seite einen Feed meiner letzten iStockphoto-Uploads einbinden wollte, aber dies nicht ging, da der offizielle Feed scheinbar nicht validiert:
http://validator.w3.org/feed/check.cgi?url=http%3A%2F%2Fwww.istockphoto.com%2Fistock_myfiles_rss.php%3FID%3D8197370

Auf WordPress verwendete ich zuerst das „Embed RSS„-Plugin um Feeds in die Seite zu integrieren, jedoch kam dies nicht mit diesem ungültigen Feed klar. Einige RSS-Reader-Programme (z.B. „Vienna RSS„) hatten jedoch keine Probleme mit dem Feed. Vermutlich korrigierten sie intern die Fehler oder ignorierten diese einfach.

Zum Glück hat mich einmal ein guter Freund in die Welt von Python eingeführt und mir die nötigen Basics dieser tollen Programmiersprache beigebracht.

Mit Hilfe der Bibliotheken „feedparser“ und „PyRSS2Gen“ konnte ich ein Python-Skript schreiben um dieses Problem umgehen.

Zuerst hole ich mit feedparser den Feed ab und baue später mit PyRSS2Gen einen neuen Feed im „RSS 2.0“-Format neu auf. Abschliessend schreibe ich diesen neuen Feed als XML-Datei in das Verzeichnis des Webservers.

Das Skript habe ich so umgebaut, dass eine beliebige iStockphoto-Benutzer-ID als Parameter übergeben werden kann. Auch die Ziel-Datei kann als Paramter übergeben werden.

Hier das Skript, welches in einem Repository auf Github gehosted ist:

#!/usr/bin/python

import datetime
import feedparser
import getopt
import os
import PyRSS2Gen
import sys

def create_latest_uploads_feed(targetPath, feedTitle, feedUrl, feedDescription, entries):
  rssItems = []
  for entry in entries:
    rssItem = PyRSS2Gen.RSSItem(
        title = entry['title'],
        link = entry['link'],
        description = entry['description'],
        guid = PyRSS2Gen.Guid(entry['link']),
        pubDate = entry['pubDate'],
        author = entry['author']
        )
    rssItems.append(rssItem)
  rss = PyRSS2Gen.RSS2(
      title = feedTitle,
      link = feedUrl,
      description = feedDescription,
      lastBuildDate = datetime.datetime.now(),
      items = rssItems)
  print 'Writing RSS feed: ' + targetPath
  rss.write_xml(open(targetPath, 'w'))
  print 'Done!'


def fetch_feed_and_create_rss(userId, targetPath):
  feedUrl = "http://www.istockphoto.com/istock_myfiles_rss.php?ID=" + userId
  print 'Fetching feed: ' + feedUrl
  feed = feedparser.parse(feedUrl)
  feedTitle = feed['feed']['title']
  feedDescription = ""
  entries = feed['entries']
  preparedEntries = []
  print 'Processing fetched entries. Entries found: ' + str(len(entries))
  for entry in entries:
    entryPubDate = entry['published']
    pubDate = datetime.datetime.strptime(entryPubDate[:-6], '%Y-%m-%dT%H:%M:%S')
    #pubDateClean = pubDate.strftime('%d.%m.%Y')
    author = entry['author']
    entryTitle = entry['title']
    print ' * Entry title: ' + entryTitle.encode('utf-8')
    link = entry['link']
    summaryHtml = entry['summary']
    preparedEntries.append({"pubDate":pubDate,"author":author,"title":entryTitle,
      "description":summaryHtml,"link":link})
  create_latest_uploads_feed(targetPath, feedTitle, feedUrl, feedDescription,
      preparedEntries)

def main(argv):
  scriptName = os.path.basename(__file__)
  usageInfo = 'usage: ' + scriptName + ' -i  -t '
  userId = ''
  targetPath = ''
  try:
    opts, args = getopt.getopt(argv,"hi:t:",["id=","targetpath="])
  except getopt.GetoptError:
    print usageInfo
    sys.exit(2)
  for opt, arg in opts:
    if opt == '-h':
      print usageInfo
      sys.exit()
    elif opt in ("-i", "--id"):
      userId = arg
    elif opt in ("-t", "--targetpath"):
      targetPath = arg
  if (userId and targetPath):
    print 'User ID is: ' + userId
    print 'Target path is: ' + targetPath
    fetch_feed_and_create_rss(userId, targetPath)
  else:
    print usageInfo
    sys.exit()


if __name__ == "__main__":
  main(sys.argv[1:])
istock_latest_uploads.pyview rawview file on GitHub

Genau genommen validiert der neue Feed immer noch nicht 🙂 allerdings sind die Fehler nun scheinbar weniger tragisch und er kann nun von „Embed RSS“ gelesen werden. Auch verwende ich nun zur Einbettung in WordPress „HungryFEED“ anstelle von „Embed RSS“, da dieses etwas mächtiger ist und bessere Templating-Option mitbringt.

Damit ich für die Webseite immer einen relativ aktuellen Feed erhalte, lasse ich das Skript mittels Crontab alle vier Stunden laufen:

#m h dom mon dow command
0 */4 * * * python /usr/local/bin/scriptXy.py -i 8197370 -t /dir/subdir/targetfile.xml
Kategorien
IT SharePoint

SharePoint: In-Operator in CAML-Queries mit mehreren Werten

Möchte man in einem CAML-Query ein Feld nach mehreren möglichen Werten „filtern“, kann man den IN-Operator/Tag verwenden.

Die verschiedenen Feldwerte werden wie auch sonst als <Value>-Tag eingesetzt, dann aber zusätzlich in einem <Values>-Tag gebündelt:

<Where>
    <In>
        <FieldRefName="Animals"/>
        <Values>
            <ValueType="Text">Cat</Value>
            <ValueType="Text">Dog</Value>
            <ValueType="Text">Fish</Value>
        </Values>
    </In>
</Where>

 

Kategorien
IT SharePoint

SharePoint: relative Pfade in XSLT verwenden

Wenn man eine SharePoint-Listenansicht mittels XSLT anpasst, so möchte man häufig auch relative Pfade verwenden.

Besonders wichtig, wenn man eine XSL-Datei für ein Feature deployed, welches in verschiedenen Webs aufgerufen wird und folglich keine absoluten Pfade sondern relative enthalten sollte.

Dies lässt sich innerhalb einer SharePoint-Seite mit der Verwendung des globalen XSLT-Parameters „ServerRelativeUrl“ einfach lösen, wie nachfolgendes Beispiel (Auszug aus einer XSL-Datei) zeigt:

                  <a href="{$ServerRelativeUrl}/Lists/Customers/DispForm.aspx?ID={@ID}">
                    <xsl:value-of select="@Title"/>
                  </a>

Man hätte natürlich auch z.B. „../Lists“ oder „http://servername/…“ voranstellen können, jedoch verliert man dann Flexibilität. Sobald der Servername geändert wird (man denke auch an „Alternate Access Mappings“ und Extranet-Lösungen)  oder das XSL auf einer Listen-Ansicht statt auf einer Page verwendet wird, geht der Link nicht mehr, da der Verweis dann einen ungültigen Pfad hat.

Damit der globale Parameter verfügbar ist, muss innerhalb der XSL-Datei die „Main.xsl“-Datei von SharePoint referenziert werden:

<xsl:stylesheet xmlns:x="http://www.w3.org/2001/XMLSchema" xmlns:d="http://schemas.microsoft.com/sharepoint/dsp" version="1.0" exclude-result-prefixes="xsl msxsl ddwrt" xmlns:ddwrt="http://schemas.microsoft.com/WebParts/v2/DataView/runtime" xmlns:asp="http://schemas.microsoft.com/ASPNET/20" xmlns:__designer="http://schemas.microsoft.com/WebParts/v2/DataView/designer" xmlns:xsl="http://www.w3.org/1999/XSL/Transform" xmlns:msxsl="urn:schemas-microsoft-com:xslt" xmlns:SharePoint="Microsoft.SharePoint.WebControls" xmlns:ddwrt2="urn:frontpage:internal">
  <xsl:import href="/_layouts/xsl/main.xsl"/>
  ...

Informationen über verfügbare globale Parameter findet ihr hier: http://msdn.microsoft.com/en-us/library/ff806158.aspx

Kategorien
IT personal

Minecraft

Vor einigen Monaten habe ich mir Minecraft gekauft, dass wohl schon seit einigen Jahren eigentlich verfügbar ist, aber immer irgendwie an mir vorbei gegangen ist.

Minecraft würde ich als eine Art Lego für Erwachsene.. oder jung gebliebene 😉 … bezeichnen. Die ganze Spielwelt, in den neueren Versionen praktisch unendlich gross, besteht aus kleinen Blöcken. Die Blöcke können aus verschiedenen Materialien bestehen, welche auch verschiedene Eigenschaften haben (fest, Wasser, Lava, Schienen, Stromkabel etc.). Im Prinzip haben alle Blöcke die gleiche Dimension, was  in etwa 1 Meter auf 1 Meter entspricht. Einige Spezialblöcke haben aber nur die Hälfte dieser grösse, eine Treppenform oder sind noch spezieller (z.B. Lampen, Schienen, Bilder, Schalter), haben aber auch dann immer im Standardblock (1m*1m) platz. Dadruch ergibt sich eine sehr spezielle Welt mit einer gewissen Lego-ästhetik.

Ein eigentliches Spielziel gibt es nicht wirklich. Es gibt einen Survival Modus, bei dem man eine Lebensenergie hat und Nahrung besorgen muss, da man ansonsten stribt. Man hat jedoch unendlich viele Leben und respawnt am ersten Spawn-Point im Spiel oder einem selber platzierten Bett. In der Nacht (es gibt einen Tag-/Nachtrythmus) und an dunklen Orten spawnen Monster, Mobs genannt, welche die eigene Spielfigur angreifen. Dort gibt es als grösseres Ziel eine Art Endboss, aber danach kann man in der freien Welt weiterspielen wie zuvor. In einem anderen Modus, „Creative“-Mode genannt, existieren keine Mobs und man hat alle Materialen unbegrenzt bereits im Inventar zur verfügung. Interessant um grössere Bauprojekte zu bewerkstelligen, aber auf die Dauer vermutlich öde. Der Survival-Modus ist sicher abwechslungsreicher und auch im Multiplayer dann nach meinem Empfinden die beliebteste Variante.

Das ganze ist dann leider auch sehr süchtig machend, so habe ich bedauerlicherweise 🙂 schon Stunden damit verbracht diese Blöcke irgendwie sinnvoll zusammen zubauen, wie z.B. das nachfolgende Video illustriert:

Zum Glück gibt es scheinbar noch Leute mit extrem viel mehr Freizeit und Zeit für diese Spiel, wie nachfolgendes Video einer Kathedrale mit über 2’000’000 Blöcken zeigt:

Für Bastler ganz interessant sind die Möglichkeiten, welche einem das Material „Redstone“ bietet, eine Art Stromleiter und Energiequelle. Man kann damit komplexeste Schaltungen bauen mit verschiedensten Logiken. Nachfolgendes Video zeigt als Beispiel einen wissenschaftlichen Taschenrechner, welcher in Minecraft umgesetzt wurde:

Ich nehme trotzdem nicht an, dass Intel/AMD etc. nun auf Minecraft umsteigen werden, um ihre zukünftigen Prozessor-Architekturen zu designen. 😉

 

Kategorien
IT SharePoint

SharePoint: Versionsnummer mit Hilfe von SharePoint Designer ermitteln

Um die Vesionsnummer des aktuell installierten SharePoint-Servers zu ermitteln gibt es viele Wege. Einige davon sind etwas umständlicher und liefern auch nicht immer leicht verständliche Ergebnise (mehere Versionsnummern z.B., wenn man in der SharePoint Central Administration unter Check product and patch installation status nachschaut).

Eine einfache Möglichkeit die aktuelle Versionsnummer der SharePoint-Installation zu ermitteln, bietet der SharePoint Designer. Einfach den Designer öffnen und auf eine Site auf dem gewünschten Server verbinden. Auf der Startseite findet man dann unter der Rubrik „Site Information“ die aktuelle Version:

SharePoint Designer Site Information
SharePoint Designer Site Information
Kategorien
IT SharePoint

SharePoint: Inhaltsdatenbank-Version an SharePoint-Version angleichen

Wenn man in einer SharePoint-Installation ein neues Cumulatives Update installiert um Programm-Fehler zu beheben, so wird die gesamte SharePoint-Version hochgehoben, also die Assemblies/Dlls etc. aktualisiert und haben dadurch höhere Versionsnummern.

Die Inhaltsdatenbank (Content Database) wird grundsätzlich aber nicht automatisch aktualisiert und behält das alte Schema und auch die alte Versionsnummer bei.

In der Regel ist dies nicht weiter tragisch, aber unter Umständen kann es trotzdem nötig werden, dass man die Inhaltsdatenbank aktualisiert und damit ihre Version an diejenige des SharePoint-Serves angleicht, so zum Beispiel, wenn man ein Backup einer Site-Collection einspielen möchte (Restore-SPSite), welches von einer Site/Datenbank mit der höheren Versionsnummer, die des Servers, entstammt.

Um manuell die Inhaltsdatenbank zu aktualisieren, kann man sich der SharePoint Management Shell bedienen.

Zuerst sollte man die gewünschte Content Database in eine Variable laden (wobei man „SQLServerName\WSS_Content_Database_Name“ durch den entsprechenden Datenbank-Server und Namen der Inhaltsdatenbank ersetzen muss):

$contentdb = Get-SPContentDatabase | Where-Object {$_.Name -match "SQLServerName\WSS_Content_Database_Name"}

Ist unklar, wie die Inhaltsdatenbank heisst, so kann man zuerst einfach nur Get-SPContentDatabase eingeben um eine Auflistung aller Inhaltsdatenbanken zu erhalten. Sollte die gewünschte Datenbank nicht aufgeführt sein, sollte sicher gestellt werden, dass diese in der Central Administration im Status „Ready“ ist.

Danach kann man mit folgendem PowerShell-Befehl die Aktualisierung starten:

Upgrade-SPContentDatabase -Identity $contentdb

In der PowerShell wird der Fortschritt in Prozent angezeigt. Bei grösseren Datenbanken kann die Aktualsierung mehrere Minute bis hin zu Stunden dauern.

Weitere Informationen findet ihr in diesem Technet-Artikel: http://technet.microsoft.com/en-us/library/ff607813.aspx