Schrift
[thread]11582[/thread]

Strategie-Vorschläge

Leser: 1


<< >> 8 Einträge, 1 Seite
Froschpopo
 2008-04-05 08:05
#107899 #107899
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
Ich habe ein relativ großes CGI-Script (ca. 60KB) das in etwa groß erklärt folgendermaßen funktioniert:
Code: (dl )
1
2
3
4
5
6
7
8
9
10
11
12
my $site_id = $cgi->param('id');
my %sites = (
home => \&home,
fotos => \&files,
profil => \&profile
);

if (exists $sites{$site_id}) {
$sites{$site_id}->(\@params);
} else {
$cgi->header(-status => '404 Not found');
}


so ganz bin ich damit nicht zufrieden. Aber es ist bequem, denn ich kann bequem alles in einem Script erledigen:
- Session-Verwaltung am Anfang des Scripts
- Datenbankverbindung einmal für das ganze Script

Viele Sachen, insbesondere oft verwendete und universelle Routinen, sind in Module ausgelagert.

Ich weiss an dieser Arbeitsweise besonders die Möglichkeit folgenden Aufbaus zu schätzen:
Code: (dl )
1
2
3
unless ($foo) {
&startseite(@_);
}

Etwas vergleichbares wäre nur möglich, wenn ich alle Seiten in Module auslagere.

Code: (dl )
1
2
3
unless ($foo) {
HTML::Seiten::Startseite(@_);
}

Ich weiss nicht was es ist, aber irgendetwas stört mich daran alles in Module auszulagern. Vielleicht sieht es nicht so schick aus oder es ist so unüblich.

Ich möchte gerne wissen, wie ihr viele Seiten strukturiert.
In PHP macht man ja häufig einfach eine index.php die dann alles enthält was für jedes Script gilt (Session-Verwaltung, Datenbank etc.) und der Rest wird dann einfach mit include einbezogen.
renee
 2008-04-05 12:09
#107902 #107902
User since
2003-08-04
14371 Artikel
ModeratorIn
[Homepage] [default_avatar]
Ich mache extra Module, die die Datenbank kapseln und ich versuche schon gleichartige Sachen in verschiedene Module auszulagern. Also die Userverwaltung im Adminbereich z.B. in ein Modul, genauso wie die Newsverwaltung etc.

Sonst besteht die Gefahr, dass das Skript viiiiiel zu groß wird.

Ich trenne meistens nicht 100%ig strikt MVC, wobei ich mir für CGI::Application eigene Viewer-Klassen gebaut habe und mittlerweile Module geschrieben habe, die mir einige Sachen von Catalyst auch in CGI::Application erlauben.

Ich sehe es als großen Vorteil, möglichst viel in Module auszulagern. So kann man mal schnell etwas in einem neuen Modul entwickeln und im Skript dann nur noch den alten Modulnamen durch den neuen Modulnamen zu tauschen und schon hast Du die neue Funktionalität...
OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/
Froschpopo
 2008-04-05 16:35
#107913 #107913
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
Also Module, wie ich schon vermutet hatte.
Wie sieht die Struktur genau aus?
Werden Die Module nur mit Standardparametern aufgerufen (z.B. Session-ID etc) oder erwartet das Hauptscript richtige Objekte und Rückgabewerte?

ich stelle mir das in deinem Fall irgendwie so vor:
Code: (dl )
1
2
3
4
5
6
my $site_id = $cgi->param('id');
my %sites = (
home => 'HTML::Startseite',
fotos => 'HTML::Images',
profil => 'HTML::VCard'
);


Aber du willst ja nicht alle Module am Anfang des Scripts mit use einbinden, weil dann wäre ja der Nutzen, Routinen nur bei Bedarf zu laden, garnicht erfüllt.
Wie bindest du die Module nur bei Bedarf ein? Mit require?
Gehen wir mal von dieser Verwendung aus:

Code: (dl )
1
2
3
4
5
6
7
if (exists $sites{$site_id}) {
# Modul laden
# Aufrufen und Standardparameter an Modul übergeben

} else {
$cgi->header(-status => '404 Not found');
}


Was mich auch noch interessieren täte: Erfolgt die Ausgabe an den Browser im Modul, oder erzeugt das Modul lediglich das HTML/XML?
renee
 2008-04-05 18:18
#107915 #107915
User since
2003-08-04
14371 Artikel
ModeratorIn
[Homepage] [default_avatar]
Ich arbeite mit CPAN:CGI::Application::Dispatch und da geht das ganz grob so:

Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
#!/usr/bin/perl -w

use strict;
use warnings;
use lib qw(./lib ../perllib);
use CGI::Application::Dispatch;

CGI::Application::Dispatch->dispatch(
    prefix => 'MyApp',
    table  => [
        '' => {
            app => 'Index',
            rm  => 'start',
        },
        'user/:id?' => {
            prefix => 'MyApp::Index',
            app => 'User',
            rm  => 'show',
        },
        'news/:id/:rm?' => {
            prefix => 'MyApp::Index',
            app => 'News',
        },
    ],
    not_found => 'http://' . $ENV{HTTP_HOST},
);


Die Module erben dann von einer eigenen Subklasse von CPAN:CGI::Application die mir einen Stash und eine View-Klasse zur Verfügung stellt.

Edit: Wenn dann http://domain.exampl/test.cgi/user/13 aufgerufen wird, dann wird halt das Modul "MyApp::Index::User" genommen.
OTRS-Erweiterungen (http://feature-addons.de/)
Frankfurt Perlmongers (http://frankfurt.pm/)
--

Unterlagen OTRS-Workshop 2012: http://otrs.perl-services.de/workshop.html
Perl-Entwicklung: http://perl-services.de/
Froschpopo
 2008-04-05 19:27
#107920 #107920
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
Also dieses http://search.cpan.org/~markstos/CGI-Application-4... ist ja im prinzip fast genau dasselbe was ich vorher gemacht habe, blos, dass alles im Modul stattfindet und in der webapp nur das Modul aufgerufen wird.
Nun ist natürlich die Frage: Theoretisch könnte ich ja dann mein ganzes Perlscript ganz simpel in ein Modul dann 60-70KB großes Modul verlagern.
Das wäre ja immernoch performanter, wie als wenn jedesmal mein Perlscript von mod_perl geklont wird.
Etwas gewöhnungsbedürftig ist es aber schon. Vor allem, weil ich es bisher immer so gehandhabt habe, dass ich nur mathematische Abläufe und alles was mit Speicher zu tun hat, in Module ausgelagert habe. Die Ausgabe usw. habe ich immer im Script gemacht.
Ich habe also bisher nur Module genutzt, um das Hauptscript zu verwalten (z.B. Caching, Handles, Config-Hashes etc.)
Froschpopo
 2008-04-05 19:54
#107921 #107921
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
hab jetzt einfach mal mein ganzes Script als pm-Datei gespeichert, package drüber geschrieben, und die webapp als mod_perl laufen lassen.

laut ab2 -n 1000 -c 10 ist die durchschnittliche Time per request jetzt 110.392 [#/sec]
Das entspricht etwa einem Performancegewinn von 40% :D
Übrigens, das ganze Perlmodul ist exakt 66KB groß.
Der Time per request enthält auch schon alle Datenbankabfragen. Also kann man davon ausgehen, dass würde das Script nicht vom Datenbankserver leicht ausgebremst werden, wäre es noch deutlich schneller.

Was man natürlich jetzt noch optimieren könnte wäre,wenn man nur noch tatsächlich verwendete Module lädt.

Bisher wird nämlich die "package"-Zeile gefolgt von einer ganzen Menge "use".

Spricht irgendetwas dagegen use in einer Subroutine aufzurufen in der es gebraucht wird?
Einige Module werden nur in ganz speziellen Subroutinen verwendet. Am besten wäre es theoretisch, sie auch nur dort einzubinden.
Macht man dass dann immernoch mit use oder lieber mit require?
pq
 2008-04-06 02:09
#107933 #107933
User since
2003-08-04
12208 Artikel
Admin1
[Homepage]
user image
Froschpopo+2008-04-05 17:54:35--
Spricht irgendetwas dagegen use in einer Subroutine aufzurufen in der es gebraucht wird?

unter mod-perl ist das komplett sinnlos. da solltest du ganz im gegenteil alle module
in der startup.pl laden.
wenn ein child-prozess 1000 mal aufgerufen wird und in den ersten 10 requests je ein
neues modul nachladen muss, ist das arbeit, die man genauso im startup machen
könnte, und ausserdem spricht für startup das shared memory.
was meinst du, warum ich bei HTC das mit startup.pl vorschlage?
Always code as if the guy who ends up maintaining your code will be a violent psychopath who knows where you live. -- Damian Conway in "Perl Best Practices"
lesen: Wiki:Wie frage ich & perlintro Wiki:brian's Leitfaden für jedes Perl-Problem
Froschpopo
 2008-04-06 03:45
#107934 #107934
User since
2003-08-15
2653 Artikel
BenutzerIn
[default_avatar]
Jetzt habe ich das Problem ja so gelöst, als dass ich nämlich meine ganze Applikation in ein Modul verlagert habe. Im Prinzip besteht die Applikation nur noch aus 3 Zeilen Code in der das Modul aufgerufen wird.
Das dürfte doch eigentlich das beste sein, oder? Weil ja die Module nicht jedesmal geklont werden müssen wie die ModPerl-Applikation.
Brauche noch eine kurze Bestätigung damit ich mich besser führe =)
<< >> 8 Einträge, 1 Seite



View all threads created 2008-04-05 08:05.