This problem is also valid for the ASUS UL30A. The touchpad is seen as an “ImPS/2 Logitech Wheel Mouse”. See in dmesg and by the command “xinput list”. I am using Ubuntu 9.10.

To disable the touchpad the following command can be used:

xinput set-int-prop “ImPS/2 Logitech Wheel Mouse” “Device Enabled” 8 0

To enable use:

xinput set-int-prop “ImPS/2 Logitech Wheel Mouse” “Device Enabled” 8 1

To make the F9 working I did the following:

1. As the F9 does not generate a keycode but an acpi event you cannot assign just a keycode to a script. So I first checked the generated event hotkey code using:
sudo acpi_listen
and pressed F9. This gives 0000006b as event hotkey code.
2. In /etc/acpi/events there is an asus-touchpad event file. This is using the wrong code so I changed it.
3. The script /etc/acpi/assus-touchpad.sh is not correct for this touchpad so I changed it (see attached script)
4. Now send the acpid a SIGHUP signal (or reboot) and the F9 button toggles your touchpad an or off.

Danach kann man via FN + F9 wieder wie gewohnt das Touchpad an- und abschalten.

MongoDb hat zwar eine group() function, die in etwa SQLs GROUP BY entspricht, allerdings kann man dies nicht kombinieren mit SORT oder LIMIT bzw den sort() und limit() Funktionen, da diese keinen Cursor zurückgibt sondern direkt ein Array.

Will man also sortieren und limitieren muss man sich des Map / Reduce features von MongoDB bedienen.

Ein Query wie folgt:

SELECT referer.URL, count(*) AS cnt
FROM `referer`
GROUP BY referer.URL
ORDER BY cnt ASC LIMIT 25

…wird dann über Command() so umgesetzt:

$map = new MongoCode("function() { emit(this.url,1); }");
$reduce = new MongoCode("function(k, vals) { ".
			"var sum = 0;".
			"for (var i in vals) {".
			"sum += vals[i];".
			"}".
			"return sum; }");
$r = $this->db_handler->command(array(
		    	"mapreduce" => "referer",
		    	"map" => $map,
		    	"reduce" => $reduce));
$r = $this->db_handler->selectCollection($r['result'])->find();
$r->sort(array('value' => -1));
$r->limit(25);
$data = array();
foreach ($r as $ref) {
	$data[$ref['_id']] = $ref['value'];
}
return $data;

In die Reduce Funktion kann man sämtliche Abfrage-Logik packen, was es zu einem ziemlich mächtigem Konstrukt macht.
Hat man sich einmal dran gewöhnt, lässt sich eine Menge damit anstellen.

Danke auch an diesen Blog.

Dieses Kommando räumt eine Sqlite Datenbank auf, killt unnötige Leerzeichen und defragmentiert den Datenbank File.

In meinem Fall war die DB nach dem löschen einer relativ großen Table immer noch auf ca 20MB, das hat mich doch stutzig gemacht und zu diesem Kommando geführt.
Nachdem ich es ausgeführt hatte, war der File dann tatsächlich auf 2MB geschrumpft!

Sollte man vielleicht nicht im laufendem Betrieb machen und als nächstes schau ich mir dann AUTO_VACUUM an.

Ubuntu Tweak ist eine Anwendung, die die Konfiguration von Ubuntu für jeden einfacher machen soll.

Ubuntu Teak ist das Ubuntu-Äquivalent für die guten, alten PowerToys/PowerTools, die bereits ab und für Windows-XP (*spit*) existieren und es dem Administrator ermöglichen, weitergehende Einstellungen des Betriebssystems, die normalerweise in Konfigurationsdateien oder teils weit verstreuten Mini-Programmen vorgenommen werden, zentral und bequem zu tätigen.

Warum es so etwas auch für Ubuntu geben muss? Ist doch klar, ein Betriebssystem, das DAUs adressiert, braucht auch DAU-Werkzeuge mit ordentlicher Bedienoberfläche.

Ich konnte mit dem Tool bspw. unglaublich einfach meine Benutzer-Ordner verschieben bzw. zurücksetzen, nachdem mein Desktop-Ordner nach irgend einem nicht mehr rekonstruierbaren, missglückten Bash-Kommando meinerseits auf /home/~user anstatt auf /home/~user/Desktop zeigte.

Da lacht natürlich der Linux-Guru drüber und editiert schnell mal ~/.config/user-dirs.dirs mit seinem Wie-Ei.

Nachtrag:
Mit Ubuntu Tweak ist es auch bequem möglich, die Fensterleisten-Knöpfe in der neuesten Ubuntu-Version wieder nach rechts zu verschieben.

Bedient man sich herkömmlicher JavaScript-Technik, muss man mit aynchronen Ajax-Requests herumkaspern, sich mit Timeouts, Memory-Leaks und Cross-Domain-Sicherheitspolicen herumschlagen. Und auch hier kommt man nicht herum, den Server zu tweaken oder gleich einen zweiten aufzusetzen, der ausschließlich auf Polls oder Long-Polls trainiert ist.

Gerade in der PHP-Welt ist es nicht einfach, einen üblichen LAMP-Stack soweit zu bringen, dass so etwas auch unter Last funktioniert – Java ist da wie immer weiter und bietet mit JMS ein einheitliches Interface – da gibt es Software für den gewöhnlichen Servletcontainer, im Anwendungsserver muss das laut Spezifikation sogar im Lieferumfang enthalten sein.

Möchte man trotzdem mit “Bordmitteln” mal schnell eine Chatbox aufsetzen, führt Longpolling + Ajax eigentlich schnell zu einem akzeptablen Ergebnis – nichts für Millionen konkurrierende Zugriffe, aber immerhin eine nette Spielerei für zwischendurch. Wäre da nicht ständiges Warten auf die Response, das sich nach einiger Zeit einerseits mit einer merklichen Ruckelorgie bemerkbar macht oder gar den Mauszeiger in eine ewiglich drehende Sanduhr verwandelt.

HTML 5 to the rescue…

HTML 5 kann sogenannte Dedicated Worker – “echte” Workerthreads auf Betriebssystemebene, die man mit einer Zeile spawnen kann.

new Worker('meinScript.js')

Innerhalb eines Threads kann man lang laufende Rechenoperationen im Hintergrund verstecken – warum also nicht auch einen Ajax-Request? Allerdings haben diese Threads einen Nachteil: Aus Sicherheitsgründen laufen sie in einem klar abgegrenzten Scope, in dem sozusagen nichts vorhanden ist. Auch keine Referenz auf das document-Object der Elternseite. Das stoppt die meisten Javascript-Bibliotheken, wie bspw. JQuery. Man muss sich also mit Bordmitteln begnügen.

Eine Methode, die einen Worker initialisiert, könnte so aussehen:

    _initializeLongPoll: function()
    {
      var messenger = this;

      var worker = new Worker('my-ajax-worker.js');
        worker.onmessage = function(event)
        {
          var json = jQuery.parseJSON(event.data);

          // NEUE CHAT-NACHRICHT ERZEUGEN
          messenger.$_list.append($('<li class="messenger-list-item">'
            + '<strong class="messenger-list-item-author">' + json.author + '</strong>'
            + '<span class="messenger-list-item-message">' + json.text + '</span></li>'));
        };
    }

“my-ajax-worker.js” ist ausschließlich für den Ajax-Request zuständig. Hier wird ein dynamisches Javascript in einem Symfony-Projekt generiert:

    var onLoad = function()
    {
      var output = httpRequest.responseText;
      if (output) {

        // DELEGIERT DIE RESPONSE ZURÜCK.
        postMessage(output.trim());

        // ERZEUGE NEUEN XmlHttpRequest
        httpRequest = initRequest();
      }
    };

    // WIR SPAREN UND DEN X-BROWSER XmlHttpRequest-KRAM
    var httpRequest = initRequest();

Details zum serverseitigen Script möchte ich an dieser Stelle vernachlässigen, im Grunde funktioniert es folgendermaßen: Es arbeitet so lange, bis eine Änderung festzustellen ist. Erst bei Änderung wird die Response an den Client ausgeliefert (darum heißt es “Long-Polling”, weil ein Request ganz schön lange dauern kann):

while(true)
{
  if(newData())
  {
    return getNewData()
  }
  sleep(5);
}

Der Kram funktioniert natürlich nur in HTML5-Browsern, die das Worker-Objekt unterstützen. Dazu zählen Firefox 3.6, Google Chrome und natürlich Safari. Ob Opera es beherrscht, weiß ich nicht, ob der IE 8 es beherrscht, bezweifle ich. Aber wie gesagt: Es ist nur eine Spielerei und keine produktiv geeignete Anwendung. Demnächst schau ich mir auch mal die WebSocket API an…

Known Issues

Vorsicht mit session_start() und konkurrierenden (asynchronen) HTTP-Zugriffen. Im User-Sessionscope wird der Apache immer auf das Schließen einer Session warten, bis er dem nächsten Request erlaubt, die Session wieder “aufzunehmen”. Und im Normalfall dauert eine User-Session genau so lange wie die Request-Lifetime. Das führt dazu, dass bei 4 gleichzeitig abgefeuerten XmlHttpRequests diese trotzdem als Stack nach dem FIFO-Prinzip abgehandelt werden. Man verliert somit den Vorteil der Asynchronität. Es ist also zwingend erforderlich, die Session bereits vor dem Long-Poll-Loop abzuschließen (durch den Aufruf von session_write_close();

in der Klasse config in der Datei .config folgendes einfügen:

public $fileExtension = '.php';

dann erwartet vork im MVC Ordner Dateien mit der Endung .php.
Um alle Dateien umzubenennen braucht man eigentlich nur Windows Vista, eine präzise Maus und etwas Geduld.
oder folgende Zeile:

find /myVorkFolder/mvc -type f -exec mv '{}' '{}'.php \;

Vork ist auf jeden Fall schnell und hat direkt einen Wrapper für PHP-MongoDB mit an Bord.
Wie man Vork auschliesslich mit Mongo nutzen kann steht hier:

If you are exclusively using MongoDB as your database (and not using an RDBMS in conjunction) then
uncomment the last line in the dbConnect() method
self::$modelObjects = array('mongo');
and comment out lines
self::$db = new $db(...)
and
self::$modelObjects[] = 'mongo';
as well as the last line in the .config file:
require '.config-rdbms';

Es gibt dann aber auch Fälle wo man dies nicht benutzen will/kann, zB weil man auf shared hosting ist oder man eine Tool ausliefern will, welches selbst aufräumen soll.

Zend_Log bietet zZt leider keine Log Rotation mit an, also muss man es selber machen:

In meinem Fall will ich die Logfiles ca eine Woche vorhalten, das sollte reichen um Problemen auf die Spur zu kommen.
Zudem werde ich die tagesweise stückeln, da diese in einem Backend angezeigt werden sollen.
Dafür nenne ich die Logfiles so:

define('SYNC_LOG','sync.'.date('N').'.log.txt');

Also mit numerischem Wochentag im Namen.

Die Pseudo Logrotation bedeutet in meinem Fall, alle LogFiles, die älter als die Woche sind, werden neu geschrieben, also der Inhalt nicht angehangen.

Dazu wird die Zend_Log_Writer Klasse extendet:

class MyZend_Log_Rotated_File extends Zend_Log_Writer_Stream{
	function __construct($file) {
		parent::__construct($file,self::rotator($file));
	}
	static function rotator($file) {
		$mode = 'w+';
		if (file_exists($file)) {
			$ft = filemtime($file);
			$yt = mktime(0, 0, 0, date('m'), date('d')-1, date('Y'));
			if($ft > $yt){
				$mode = 'a';
			}
		}
		return $mode;
	}
}

Jetzt wird bei jeder Instanzierung geprüft ob der File zu alt ist und der Öffne-Modus dementsprechend gesetzt und der Parent Klasse, also dem Zend_Log_Writer übergeben.

So wird es dann aufgerufen:

$logger = new Zend_Log();
$writer = new MyZend_Log_Rotated_File(LOGDIR.SYNC_LOG);
$logger->addWriter($writer);
$logger->log('log was!');

Und Doctrine macht auch in Sachen Mongo, hab ich gerade gesehen.
http://www.doctrine-project.org/projects/mongodb_odm

Wer’s noch nicht gesehen hat, muss(!) auch mal dieses online shell tutorial auf http://www.mongodb.org anschauen.

http://astuteo.com/slickmap/
http://astuteo.com/slickmap/demo