Ein guter Freund von mir war so freundlich, ein Python QT Interface zu meiner Website Thumbnailer API zu bauen.

Screenshot | Download

Hier der Sourcecode:

from PyQt4.QtCore import *
from PyQt4.QtGui import *
from PyQt4.QtNetwork import *

from designs.FetchDialog import Ui_FetchDialog

import os,sys



class MainClass(QDialog):
    def __init__(self, parent = None):
        super(QDialog, self).__init__()
        
        QApplication.setStyle(QStyleFactory.create('plastique'))
        
        self.layout = Ui_FetchDialog()
        self.layout.setupUi(self)
        
        self.layout.progress.hide()
        self.layout.btn_save.hide()
        self.layout.pic.hide()
        
        self.connect(self.layout.btn_save, SIGNAL("pressed()"), self.saveDownloadedImage)
        self.connect(self.layout.btn_get, SIGNAL("pressed()"), self.progressDownload)
        
    def progressDownload(self):
        self.layout.progress.setValue(0)
        self.layout.progress.show()
        
        self.networkmanager = QNetworkAccessManager();

        request = QNetworkRequest()
        url = "http://codejungle.org/api/thumb_get.php?url=%s" % self.layout.url.text()

        request.setUrl(QUrl(url))
        
        self.reply = self.networkmanager.get(request)
        self.connect(self.reply, SIGNAL("downloadProgress(qint64,qint64)"), self.updateProgressBar)
        self.connect(self.networkmanager, SIGNAL("finished(QNetworkReply *)"), self.showThumbnail)
    
    def showThumbnail(self, replyFromServer):
        if(replyFromServer.isFinished() == True):
            imageData = replyFromServer.readAll()
            
            if(imageData.size() == None):
                print "Error while reading image!"
            
            pixmap = QPixmap()
            pixmap.loadFromData(imageData)
            
            self.originalPixmap = pixmap
            
            if(pixmap.width() > 800):
                pixmap = pixmap.scaledToWidth(800)

            self.layout.pic.setPixmap(pixmap)
            self.layout.pic.setMaximumHeight(600)
            self.layout.pic.setMaximumWidth(800)
            
            
            self.layout.pic.show()
            self.layout.btn_save.show()
            
            replyFromServer.deleteLater()
            
    def saveDownloadedImage(self):
        saveTo = QFileDialog.getSaveFileNameAndFilter(parent=None, caption=QString(), directory = QString(), filter = "Images (*.png)")
              
        if(self.originalPixmap.save(saveTo[0], "png")):
            QMessageBox.information(self, "Success!", "Your image is now saved!")
            
            self.layout.pic.hide()
            self.layout.btn_save.hide()
            self.resize(530, 132)

    def updateProgressBar(self, bytesRecieved, bytesTotal):
        self.layout.progress.setMaximum(bytesTotal)
        self.layout.progress.setValue(bytesRecieved)
        
        if(self.layout.progress.value() == bytesTotal):
            self.layout.progress.hide()
    
if __name__ == "__main__":
    app = QApplication([])
    software = MainClass()
    software.show()
    app.exec_()

Known Bugs:

• Die Vorschau zeigt bei manchen Webseiten nur einen Teil an, generiert und gespeichert wird davon unabhängig das Bild der ganzen Webseite.
  
• Einige Sonderzeichen in der Adresse machen noch Probleme.

Vielen Dank an Mario (www.unite-it.at) an dieser Stelle.

Andreas

Ich habe in einem Artikel von der Möglichkeit geschrieben mit
MySQL-Proxy eine lastenverteilte Datenbank aufzubauen.

Heute möchte ich jedoch eine andere Alternative vorstellen.
Ich habe zu diesem Zweck eine Datenbank Lastenverteilungsklasse geschrieben.
Sie stellt drei Methoden zur Lastenverteilung bereit:

Simple Load Balancing verteilt die Last völlig willkürlich:
Vorteil: relativ schnell
Nachteil: Server können einseitig belastet werden

Load Balancing by Weight verteilt die Last nach Gewichtung:
Hat man z.B. eine starke und zwei schwache Maschinen
ist es möglich der starken mehr Gewichtung zu geben.
Nachteil: Der richtige Gewichtungswert von Maschinen ist schwer zu ermittelen
und kann sich im regulären Betrieb unerwartet ändern.

Load Balancing by Load verteilt die Last nach Systemauslastung:
Vorteil: Die Last wird an den Server verteilt, der am wenigsten zu tun hat.
Nachteil: Die zusätzliche Zeit, die benötigt wird, um die Systemlast der Server abzufragen.
Läuft nur unter Linux, benötigt memcache.

Derzeit wird die Systemlast 60 Sekunden im memcache zwischengespeichert um unnötige Anfragen
an den Webserver zu sparen,
evtl. muss dieser Wert angepasst werden, damit unter hoher Last die Maschinen nicht einseitig
belastet werden.


Desweiteren stellt die Klasse eine Methode zum Abfragen der durchschnittlichen Systemlast bereit
und ausserdem eine Methode die endscheiden kann, ob eine Abfrage auf den Master oder Slave laufen soll.


Code

Ich habe versucht die Methoden so generisch zu schreiben, dass man sie auch für andere
Lastenverteilung nutzen kann.
Es ist ebenso denkbar, gewisse Methoden zu kombinieren.

Ich hoffe euch hat mein kleiner Artikel zur Lastenverteilung gefallen,
über Feedback würd' ich mich wie immer sehr freuen.

Eine Warnung noch zum Schluss, bitte verwendet die Klasse nicht ohne gezieltes
Benchmarking und Testing im Produktivsystem.


LG

Andreas

Ich habe mir gedacht, nachdem ich ja sonst nix zu tun habe, ein paar
Tage lang eine bestehende Applikation so umzuschreiben, dass
sie auf mehreren Servern läuft.
Als Basis werde ich meinen Reminder Service verwenden.

Der erste Schritt um die Performance zu verbessern ist immer
die Analyse der bestehenden Applikation, dazu gehört auch das Profiling, um
Bottlenecks besser zu lokalisieren.

Um die Skalierbarkeit zu verbessern, werde ich
gewisse Teile ausgliedern, man nennt dies auch funktionale
Partitionierung.
Man könnte bei einem typischen Blog zum Beispiel anfangen,
Kommentare, Benutzer und Nachrichten jeweils auf eine eigene Datenbank auszulagern.
Weiters könnte man mit Hilfe eines Lastenverteilers und mehreren Webservern die
Last aufteilen.

In unserem Beispiel haben wir zwei Kernbereiche, erstens das Userinterface,
worüber der Benutzer Daten anlegen, verändern und löschen kann und
zweitens das Backend, welches die eingegebenen Daten verarbeitet.

Im Idealfall können wir am Ende das Front und Backend auf N Servern horizontal skalieren.
Das bedeutet, wir erhöhen nicht nur die Geschwindigkeit, sondern schaffen zusätzlich Redundanzen,
die eine gewisse Ausfallsicherheit garantieren.

Schauen wir uns das bestehende Backend mal an:
Code

Schon wieder Omas Geburtstag vergessen?
Der Arzttermin war doch am Montag, oder war es doch Dienstag?
Was war noch mal die wichtige Sache, die ich heute unbedingt noch machen wollte?
Und wann fängt eigentlich das Meeting an?

Peinliche Situationen, die man sich mit meinem neuen Reminder Service
ersparen kann.
Der Sourcecode ist wie immer OpenSource, doch müsst
ihr euch noch ein paar Wochen gedulden.
Ich möchte zuerst sicherstellen, dass der Reminder Service
auch wirklich stabil läuft und dafür brauch ich möglichst viele Betatester.
Wenn du mir dabei helfen magst kannst du Remind ME hier testen:
http://www.codejungle.org/reminder/

LG
Andreas