Unabhängige Prozesse mit multiprocessing

[jtschoch]

Hallo ich bins wider,

Und zwar habe ich ein Problem mit multiprocessing.
Ich schreibe zurzeit mit Bottle an einer Webframework und dabei möchte ich über ein GTK-dialog mehrere Dateien auswählen.
Das mit den Dateien funktioniert schon, aber ich muss das Programm in einen unabhängigen Prozess auslagern, weil das sonst auf den Serverprozess läuft.
Deswegen kann ich das Programm nicht schließen.
Meine Frage ist wie ich einen Unabhängigen Prozess erzeugen kann und der auch das GTK programm schließen lässt?


Codes:

Upload-Teil, wo der Unabhängige Prozess sein soll(filechooser())

Code: Alles auswählen

    @route('/action/upload', method='POST')
    def do_upload():
        result_queue = Queue()
        def filechooser():
            g = PictureWall_gui.Gui()
            g.dialog()
            files = g.getfiles()
            result_queue.put(files)

        gui = Process(target=filechooser)
        gui.start()
        gui.run()

        cssfile = module.configloader.getCSSconfig()
        newFileList=[]

        for file in result_queue.get():
            file = file.replace("/", "&")
            newFileList.append(file)
        return template("templates/album_after_upload.tpl", css=cssfile, files=newFileList)

Die Main (Der Server läuft schon in extra Prozess),
aber es existiert noch keine GUI di bau ich später ein(app)

Code: Alles auswählen

def main():

    server = Process(target=PictureWall_server.run_server)
    server.start()

    app = Process(target=PictureWall_gui.Gui)
    app.start()

    app.join()
    server.terminate()

Die GUI

Code: Alles auswählen

from gi.repository import Gtk
import module.configloader

class PictureWall(Gtk.Window):
    def __init__(self):
        Gtk.Window.__init__(self)
        self.buttonbox = None
        module.configloader.setConfigs()
        self.connect("destroy", Gtk.main_quit)

    def dialog(self): 
        self.buttonbox = Gtk.HButtonBox()
        self.add(self.buttonbox)
        button = Gtk.Button(label="Fortfahren")
        button.connect("clicked", self.on_close_clicked)
        self.buttonbox.add(button)
    
        dialog = Gtk.FileChooserDialog(title="FileChooserDialog", parent=self, buttons=(Gtk.STOCK_OK, Gtk.ResponseType.OK, Gtk.STOCK_CANCEL, Gtk.ResponseType.CANCEL))
        dialog.set_select_multiple(True)
        #add_filters(dialog)
        response = dialog.run()
        if response == Gtk.ResponseType.OK:
            print "Open clicked"
            self.files = dialog.get_filenames()
        elif response == Gtk.ResponseType.CANCEL:
            print "Cancel clicked"
            dialog.destroy()
        
        dialog.destroy()
        self.show_all()
        Gtk.main()
        
    def getfiles(self):
        return self.files
    
    def on_close_clicked(self, button):
        print "Closing application"

        Gtk.main_quit()

class Gui(PictureWall):
    def __init__(self):
        PictureWall.__init__(self)

Ich Hoffe ihr könnt mir Helfen.

[BlackJack]

@jtschoch: Ich würde das komplett voneinander trennen. Ein Webserver mit einer GUI auf dem Server klingt abenteuerlich.

[jtschoch]

Ne, das soll über Webkit eingebunten werden und da soll er das gleich mit Starten, ausserdem läuft ja die Gui und der Server getrennt, das Problem ist nur beim Auswahldialog,
denn der Prozess soll extra laufen und auch schließbar sein.

[jerch]

@jtschoch:
Erklär' doch bitte mal genauer, was Du vorhast. Das "über Webkit einbinden" und das Starten von GUI-Komponenten aus dem HTTP-Server heraus klingt komisch uns letzteres ist mit Sicherheit kein guter Weg.

Prinzipiell kannst Du aus bottle heraus länger laufende Prozesse kreieren. Da bottle aber häufig als Komponente eines "größeren" HTTP-Servers im Lifebetrieb verwendet wird, musst Du das Prozessverhalten dieser Server hinsichtlich eines Requestzyklus' kennen (zB. beim Apache prefork vs. threaded). Das hat Konsequenzen darauf, ob Du den Prozess zB. entkoppeln musst oder in einem serverglobalen Kontext verfolgen kannst/darfst. Das hat dadurch wiederum Konsequenzen auf die mgl. Server/-einstellungen, über die bottle betrieben werden können. Hinzu kommt, das einige Server zu lange laufende Kinder töten, um Ressourcen frei zu machen, da hilft dann nur die Entkopplung. Alles in allem - nix schön und nix gut, HTTP ist nicht dafür gemacht.

GUI als Client gebaut, so wird ein Schuh draus. Im Falle eines eines HTTP-Servers schreit das ja förmlich nach einem webbasierten Frontend.

[Sirius3]

Code: Alles auswählen

<input type="file" name="daten">

und schon hat man im Browser einen wunderschönen File-Open-Dialog.

[jtschoch]

@Sirius3: Ja schon, aber ich möchte mehrere Dateien wählen und der gibt mir nur eine zurück.

[sparrow]

Code: Alles auswählen

<input type="file" name="daten[]" multiple>

[jtschoch]

Danke,

aber ich brauche dann den Datei-Pfad.

Code: Alles auswählen

from bottle import route, request
@route('/upload', method='POST')
def do_upload():
    name = request.forms.name
    data = request.files.data
    if name and data and data.file:
        raw = data.file.read() # This is dangerous for big files
        filename = data.filename
        return "Hello %s! You uploaded %s (%d bytes)." % (name, filename, len(raw))
    return "You missed a field."

damit komm ich nicht weit.

[sparrow]

Welchen Dateipfad?

[jtschoch]

Den von der ausgewählten Datei

[sparrow]

Das verstehe ich nicht. Was genau tut denn nicht?

Der Thread hier enthält ein komplettes Beispiel wie man das in bottle umsetzt. Das funktioniert auch problemlos.

Damit kann man mehrere Dateien per POST unter den kompatiblen Webbrowsern auswählen und auch hochladen. Und zwar ohne externe Programme...

[jtschoch]

Ja schön nur ich brauche keinen Dateinamen sondern Dateipfad, denn ich möchte die Bilder nicht lokal alles in einen Ordner
kopieren, wäre ja sonnst Platzverschwendung!

Edit:

Die Anwendung soll nicht auf einen Webserver laufen der Server läuft lokal im Hintergrund.

[BlackJack]

@jtschoch: Ich verstehe immer noch nicht was diese komische Architektur soll. Warum ein Webserver wenn dann doch ein GUI-Toolkit verwendet wird? Wenn man aus der Weboberfläche „native” GUI-Dialoge starten will, dann ist das IMHO konzeptionell etwas falsch oder zumindest reichlich eigenartig.