Esecuzione di più di una classe in Cherrypy

Question

Sto provando a creare un piccolo sito con un indice ecc. E un'ape che voglio in/api.

Ad esempio:

class Site(object): 
    @cherrypy.expose 
    def index(self): 
     return "Hello, World!" 
    @cherrypy.expose 
    def contact(self): 
     return "Email us at..." 
    @cherrypy.expose 
    def about(self): 
     return "We are..." 

class Api(object): 
    @cherrypy.expose 
    def getSomething(self, something): 
     db.get(something) 
    @cherrypy.expose 
    def putSomething(self, something) 

Così, mi piacerebbe essere in grado di andare a mysite.com/contact e mysite.com/Api/putSomething

Se uso cherrypy.quickstart(Site()), I' Riceverò solo le pagine sotto Sito.

Penso che ci sia un modo di mappare la classe Api sotto/Api, ma non riesco a trovarlo.

Answer 1

Aggiornamento (13 marzo 2017): La risposta originale di seguito è piuttosto obsoleta, ma la sto lasciando così com'è da riflettere la domanda originale che è stata posta.

The official documentation now has a proper guide on how to achieve it.

---

risposta originale:

Guarda il dispatcher di default. The entire documentation for Dispatching.

Citando dalla documentazione:

root = HelloWorld() 
root.onepage = OnePage() 
root.otherpage = OtherPage() 

Nell'esempio precedente, l'URL http://localhost/onepage punterà al primo oggetto e l'URL http://localhost/otherpage punterà al secondo. Come al solito, questa ricerca viene eseguita automaticamente.

This link gives even more detail on it with a complete example shown below.

import cherrypy 

class Root: 
    def index(self): 
     return "Hello, world!" 
    index.exposed = True 

class Admin: 
    def user(self, name=""): 
     return "You asked for user '%s'" % name 
    user.exposed = True 

class Search: 
    def index(self): 
     return search_page() 
    index.exposed = True 

cherrypy.root = Root() 
cherrypy.root.admin = Admin() 
cherrypy.root.admin.search = Search() 

Answer 2

Come fumanchu accennato, è possibile creare diverse sottosezioni al tuo sito con più chiamate a cherrypy.tree.mount. Qui di seguito è una versione semplificata di un sito che sto lavorando su questo consiste sia una web app front-end e un API riposante:

import cherrypy 
import web 

class WebService(object): 

    def __init__(self): 
     app_config = { 
      '/static': { 
       # enable serving up static resource files 
       'tools.staticdir.root': '/static', 
       'tools.staticdir.on': True, 
       'tools.staticdir.dir': "static", 
      }, 
     } 

     api_config = { 
      '/': { 
       # the api uses restful method dispatching 
       'request.dispatch': cherrypy.dispatch.MethodDispatcher(), 

       # all api calls require that the client passes HTTP basic authentication 
       'tools.authorize.on': True, 
      } 
     } 

     cherrypy.tree.mount(web.Application(), '/', config=app_config) 
     cherrypy.tree.mount(web.API(), '/api', config=api_config) 

    # a blocking call that starts the web application listening for requests 
    def start(self, port=8080): 
     cherrypy.config.update({'server.socket_host': '0.0.0.0', }) 
     cherrypy.config.update({'server.socket_port': port, }) 
     cherrypy.engine.start() 
     cherrypy.engine.block() 

    # stops the web application 
    def stop(self): 
     cherrypy.engine.stop() 

Creazione di un'istanza di WebService inizializza due diverse applicazioni web. La prima è la mia applicazione front-end, che vive a web.Application e verrà pubblicata allo /. La seconda è la mia API riposante, che vive a web.API e verrà pubblicata allo /api.

Le due viste hanno anche diverse configurazioni. Ad esempio, ho specificato che l'API utilizza l'invio del metodo e che l'accesso ad esso è regolato dall'autenticazione HTTP di base.

Dopo aver creato un'istanza di WebService, è possibile richiamare l'avvio o l'arresto su di esso in base alle esigenze e si occupa di tutte le operazioni di pulizia.

Cose davvero interessanti.