>From here : http://code.google.com/appengine/docs/webapp/running.html

// Tip: App Engine routes requests to Python scripts based on the URL
and mappings specified in the application's app.yaml file. A webapp
WSGIApplication further maps specific URL paths to request handlers.
How you use both mappings is up to you: You could have all non-static
URLs go to a single Python script, and have the script dispatch all
dynamic URLs to handlers. Or, you can group functionality into
multiple WSGI applications run by different scripts, and use app.yaml
to map the appropriate URLs to the appropriate applications. //

So the conclusion is : "how you use both mappings is up to you"

Personnaly, in my app.yaml :
- url: .*
  script: main.py

Then I dispatch in "main".

I use 2 handlers, if I've 2 (or more) different apps : for example :
handlers:
- url: /zipme
  script: zipme.py <--- to zip my project.

- url: .*
  script: main.py








On 20 oct, 11:52, JFQueralt <[EMAIL PROTECTED]> wrote:
> So far no one has posted any impression on this.
> I feel strange about it.
>
> Jean
>
> On Oct 15, 2:52 am, Sal <[EMAIL PROTECTED]> wrote:
>
> > That's a good question. I personally route to the appropriate handlers
> > inside a main.py module. I pretty much adopted this approach from GvRs
> > presentation. But I have to admit, I don't know of any significant
> > advantages of one approach versus the other. I would like to see what
> > other ppl think.
>
> > On Oct 14, 10:29 am, JFQueralt <[EMAIL PROTECTED]> wrote:
>
> > > Hi, everyone.
>
> > > I am not sure this question has been raised in the past but I searched
> > > a little bit and could not find any topic covering this doubt I am
> > > having. Also, I am a newbie on this technologies so maybe my question
> > > is kind of obvious.
>
> > > - YAML allows us to map URL patterns to modules in written in Python.
> > > - Inside a module, I can map an URL to a handler.
>
> > > This basically means to me that I have 2 options to handle the
> > > following common scenario:
>
> > > Root
> > > ---------Folder A
> > > -----------------File 1
> > > -----------------File 2
> > > -----------------File 3
> > > -----------------File 4
> > > -----------------File 5
>
> > > ---------Folder B
> > > -----------------File 1
> > > -----------------File 2
> > > -----------------File 3
>
> > > First option:
> > > -> YAML can map the whole folder A to a module and inside the module I
> > > further discriminate the right handler to each File.
>
> > > Second option:
> > > -> YAML maps directly a separate module per each File (which therefore
> > > contains only one handler for that particular File).
>
> > > My doubt concerns performance, stability and the like.
> > > While I don´t mind coding more modules, I am not sure what´s more
> > > performant.
> > > From a discrimination level, it does not seem to make any difference
> > > to me (do it at YAML level or module level... it´s basically the same)
> > > but then other aspects might be considered.
>
> > > Any ideas?
>
> > > Cheers.
>
> > > Jean
--~--~---------~--~----~------------~-------~--~----~
You received this message because you are subscribed to the Google Groups 
"Google App Engine" group.
To post to this group, send email to [email protected]
To unsubscribe from this group, send email to [EMAIL PROTECTED]
For more options, visit this group at 
http://groups.google.com/group/google-appengine?hl=en
-~----------~----~----~----~------~----~------~--~---

Reply via email to