mysql Passwort zurücksetzen

Wenn man das root Passwort des mysql Servers vergessen hat, lässt sich dieses wie folgt zurücksetzen:

Zuerst muss man mysql beenden und dann manuell im „safe mode“ starten. Danach kann man sich mit root ohne Passwort anmelden:

/etc/init.d/mysqld stop
mysqld_safe --skip-grant-tables &
 
mysql -uroot

Nun kann das Passwort in mysql neu gesetzt werden:

USE mysql;
 
UPDATE USER SET password=PASSWORD("NeuesPasswort") WHERE USER='root';
 
FLUSH privileges;
 
quit

Zu guter leztzt muss man den manuell gestarteten mysql Prozess wieder killen und kann mysql normal starten. Danach ist ein Login mit dem neuen Passwort wieder möglich:

killall mysqld
 
/etc/init.d/mysqld start
 
mysql -u root -p

OpenVPN: option ‚route‘ cannot be used in this context

Damit man vom OpenVPN Server auf die OpenVPN Client Netze zugreifen kann ist in der Konfiguration des Servers die Option:

route NETZWERK NETMASK

einzutragen und zusätzlich im client-config-dir eine Datei mit dem Namen des clients und einer iroute:

iroute NETZWERK NETMASK

Nun könnte man auf die Idee kommen, dass man das „route“ Kommando auch gleich ins Client config file packt, so dass die route nicht schon beim starten des OpenVPN Servers, sondern erst beim Verbinden des Clients erstellt würde.

Dies schlägt jedoch Fehl und man bekommt die irreführende Meldung:

option 'route' cannot be used in this context

angezeigt.

Obwohl es wahrscheinlich technisch möglich wäre, geht OpenVPN davon aus, dass man in der Konfiguration user/group auf etwas anderes als „root“ gesetzt hat (was sicherheitstechnisch auch sehr zu empfehlen ist!).
In diesem Falle startet openvpn zwar als root (und setzt die routen gemäss den „route“ Kommandos) entsprechend, doch gibt nachher die root Rechte ab und läuft als user (meist: „openvpn“) weiter. Dann ist es gar nicht mehr möglich mit User-Privilegien eine route im System zu setzten, weshalb OpenVPN das entsprechend von vornherein gar nicht zulässt.

UniFi als Linux Service

Die UniFi WLAN Access Points gelten aktuell als das Nonplusultra wenn es um günstige Enterprise Hardware geht.

Doch diese erfordern zum konfigurieren eine java Webapplikation, welche offiziell nur als Desktopanwendung unterstützt wird – Und dort nicht gerade gut, bei einigen Konfiguration läuft es, bei anderen nicht.

Doch es gibt eine inoffizielle Version der Software, welche man ganz einfach auf einem Linux Server installieren kann und die gut läuft! Dies ist meiner Meinung nach auch die bessere Variante, da man in der Regel das Konfigurations-Webinterface ohnehin immer Abrufbar haben will.

Mit ein paar einfachen Schritten lässt isch die Software als CentOS/RHEL service installieren und mit ein paar kleinen Anpassungen passt sie auch auf andere Linux Systeme wie debian oder ubuntu.
Continue reading UniFi als Linux Service

nagios check_file_age: File not found nach update auf 2.1.4

Nach dem update des nagios-plugins check_file_age schlagen alle Checks fehl mit der Meldung: „File not found“, obwohl die Datei vorhanden ist.
Continue reading nagios check_file_age: File not found nach update auf 2.1.4

Python logger für Konsole und Logfiles

Mittels des logging Moduls in python lassen sich nicht nur log messages für Log-Dateien erstellen, sondern auch die normalen Nachrichten welche man auf der Konsole ausgibt. – Das hat den Vorteil, dass  man die Ausgabe danach beliebig nur noch in logfiles schreiben- (z.B. mit einem „–quiet / -q“ Paramater), oder mehr Nachrichten auf der Konsole ausgeben kann (z.B. mit einem –verbose / -v) Parameter.

Zuerst erstellt man am besten eine eigene Funktion, welche das logging initialisiert:

import logging
 
def init_logging():
  # create logger
  global logger
  logger = logging.getLogger("script name")
 
  # create handlers
  logfile_handle = logging.FileHandler(filename = "log.log")
  console_handle  = logging.StreamHandler()
 
  # set loglevel
  logger.setLevel(logging.DEBUG)
  logfile_handle.setLevel(logging.DEBUG)
  console_handle.setLevel(logging.INFO)
 
  # add handlers to logger
  logger.addHandler(logfile_handle)
  logger.addHandler(console_handle)
 
  # create Formatting
  format_file    = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
  format_console = logging.Formatter("\033[0;32m%(asctime)s\033[0m - %(message)s")
 
  # add formatter to handler
  logfile_handle.setFormatter(format_file)
  console_handle.setFormatter(format_console)
 
  logger.debug("Logging initialized")
 
init_logging()

Danach kann die Ausgabe wie folgt aufrufen:

logger.info("This informational message only goes to console.")
logger.warn("This warning message only goes to console")

sqlite mit python

Zur Datenspeicherung in lokalen Programmen bietet sich die Datei-basierte Datenbank sqlite ideal an!

Die folgende Klasse stellt dabei die Grundlegenden Funktionen zum Umgang mit einer sqlite Datenbank zur Verfügung:

import os
import sqlite3
 
###############################################################################
# modifies the delivery database                                              #
# lists, adds and removes projects or recipients                              #
###############################################################################
class sqliteDB:
 
  #############################################################################
  # Creates a new sqlite database                                             #
  #############################################################################
  def create(self, dbfile):
    if not os.path.isfile(dbfile):
      self.sqlquery(dbfile, "CREATE TABLE 'table1' ('TID' INTEGER PRIMARY KEY AUTOINCREMENT NOT NULL, 'TOtherTableID' INTEGER NOT NULL, 'TName' TEXT NOT NULL, 'TDescription' TEXT)")
      return dbfile
    else:
      return 1
 
 
  ###############################################################################
  # queries the database and returns a dictionary of rows                       #
  #                                                                             #
  # takes:   string            = String of SQL-Code                             #
  # returns: dict              = dict of rows                                   #
  ###############################################################################
  def sqlquery(self, dbfile, sql):
    try:
      con = sqlite3.connect(dbfile)
      con.row_factory = sqlite3.Row
      cur = con.cursor()
      cur.execute(sql)
      con.commit()
 
      rows = cur.fetchall()
      con.close()
 
    except sqlite3.Error, e:
      msg = "Error %d: %s" % (e.args[0], e.args[1])
      print msg
 
    return rows

Und so wird die sqliteDB-Klasse Benutzt:

# Define database file
myDBfile = "sqlite.db"
 
# Create a new database
myDB = sqliteDB().create(myDBfile)
if myDB == myDBfile:
  print "Created database: '{myDB}'".format(myDB = myDB)
else:
  print "DB file already existent. If you want to create a NEW database, please delete the file:\n{filename}\n".format(filename = myDBfile)
 
# Insert data in database
sqliteDB().sqlquery(myDBfile, "INSERT INTO table1 (TOtherTableID, TName) VALUES (1, 'My first row')")
sqliteDB().sqlquery(myDBfile, "INSERT INTO table1 (TOtherTableID, TName) VALUES (2, 'My second row')")
 
# Select data from database
rows = sqliteDB().sqlquery(myDBfile, "SELECT TName FROM table1")
 
# Show data
for row in rows:
  print row['TName']
 
# Delete data
sqliteDB().sqlquery(myDBfile, "DELETE  FROM table1  WHERE TOtherTableID = 2")

Bestätigungsabfrage

Will man in seinen python Scripts fragen ob weiter gemacht werden soll (ähnlich wie beim Installieren von Paketen in Paketmanagern) bietet sich diese F8unktion ans:

def ask_proceed(question, default="yes"):
    valid = {"yes":"yes", "y":"yes", "no":"no", "n":"no"}
    if default == None:
      prompt = " [y/n] "
    elif default == "yes":
      prompt = " [Y/n] "
    elif default == "no":
      prompt = " [y/N] "
    else:
      raise ValueError("invalid default answer: '%s'" % default)
 
    while 1:
      print (question + prompt)
      choice = raw_input().lower()
      if default is not None and choice == '':
        return default
      elif choice in valid.keys():
        return valid[choice]
      else:
        print ("Please respond with 'yes' or 'no' (or 'y' or 'n').\n")
 
 
result = ask_proceed("Do you want to continue?")
if result == "yes":
  print "A good choise! I will continue with whatever I was doing..."
if result == "no":
  print "Ok, bye!"