initial commit for website

Author: jh0ker

djangoplugin.py

@@ -0,0 +1,38 @@
+# -*- coding: utf-8 -*-
+import imp
+import os, os.path
+
+import cherrypy
+from cherrypy.process import plugins
+
+from django.conf import settings
+from django.core.handlers.wsgi import WSGIHandler
+
+from httplogger import HTTPLogger
+
+__all__ = ['DjangoAppPlugin']
+
+class DjangoAppPlugin(plugins.SimplePlugin):
+    def __init__(self, bus, application, settings_module, wsgi_http_logger=HTTPLogger):
+        """ CherryPy engine plugin to configure and mount
+        the Django application onto the CherryPy server.
+        """
+        plugins.SimplePlugin.__init__(self, bus)
+        
+        self.application = application
+        self.settings = settings_module
+        self.wsgi_http_logger = wsgi_http_logger
+
+    def start(self):
+        """ When the bus starts, the plugin is also started
+        and we load the Django application. We then mount it on
+        the CherryPy engine for serving as a WSGI application.
+        We let CherryPy serve the application's static files.
+        """
+        
+        cherrypy.log("Loading and serving the Django application")
+        
+        cherrypy.tree.graft(self.wsgi_http_logger(self.application), '/')
+        # cherrypy.tree.graft(self.application, '/')
+        
+        

httplogger.py

@@ -0,0 +1,60 @@
+# -*- coding: utf-8 -*-
+import logging
+import sys
+
+import cherrypy
+from cherrypy import _cplogging, _cperror
+from django.http import HttpResponseServerError
+
+class HTTPLogger(_cplogging.LogManager):
+    def __init__(self, app):
+        _cplogging.LogManager.__init__(self, id(self), cherrypy.log.logger_root)
+        self.app = app
+
+    def __call__(self, environ, start_response):
+        """
+        Called as part of the WSGI stack to log the incoming request
+        and its response using the common log format. If an error bubbles up
+        to this middleware, we log it as such.
+        """
+        try:
+            response = self.app(environ, start_response)
+            self.access(environ, response)
+            return response
+        except:
+            self.error(traceback=True)
+            return HttpResponseServerError(_cperror.format_exc())
+
+    def access(self, environ, response):
+        """
+        Special method that logs a request following the common
+        log format. This is mostly taken from CherryPy and adapted
+        to the WSGI's style of passing information.
+        """
+        
+        if 'status_code' not in dir(response):
+            return
+        
+        atoms = {'h': environ.get('REMOTE_ADDR', ''),
+                 'l': '-',
+                 'u': "-",
+                 't': self.time(),
+                 'r': "%s %s %s" % (environ['REQUEST_METHOD'], environ['REQUEST_URI'], environ['SERVER_PROTOCOL']),
+                 's': response.status_code,
+                 'b': str(len(response.content)),
+                 'f': environ.get('HTTP_REFERER', ''),
+                 'a': environ.get('HTTP_USER_AGENT', '')
+                 }
+        for k, v in atoms.items():
+            if not isinstance(v, str):
+                v = str(v)
+            # Fortunately, repr(str) escapes unprintable chars, \n, \t, etc
+            # and backslash for us. All we have to do is strip the quotes.
+            v = repr(v)[1:-1]
+            # Escape double-quote.
+            atoms[k] = v.replace('"', '\\"')
+
+        try:
+            self.access_log.log(logging.INFO, self.access_log_format.format(**atoms))
+        except:
+            self.error(traceback=True)

manage.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+import os
+import sys
+
+if __name__ == "__main__":
+    os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ptb_website.settings")
+
+    from django.core.management import execute_from_command_line
+
+    execute_from_command_line(sys.argv)

ptb_website/__init__.py

@@ -0,0 +1,23 @@
+"""ptb_website URL Configuration
+
+The `urlpatterns` list routes URLs to views. For more information please see:
+    https://docs.djangoproject.com/en/1.8/topics/http/urls/
+Examples:
+Function views
+    1. Add an import:  from my_app import views
+    2. Add a URL to urlpatterns:  url(r'^$', views.home, name='home')
+Class-based views
+    1. Add an import:  from other_app.views import Home
+    2. Add a URL to urlpatterns:  url(r'^$', Home.as_view(), name='home')
+Including another URLconf
+    1. Add an import:  from blog import urls as blog_urls
+    2. Add a URL to urlpatterns:  url(r'^blog/', include(blog_urls))
+"""
+from django.conf.urls import include, url
+from django.contrib import admin
+
+
+urlpatterns = [
+    url(r'^admin/', include(admin.site.urls)),
+    url(r'^$', include('website.urls'))
+]

ptb_website/urls.py

@@ -0,0 +1,16 @@
+"""
+WSGI config for ptb_website project.
+
+It exposes the WSGI callable as a module-level variable named ``application``.
+
+For more information on this file, see
+https://docs.djangoproject.com/en/1.8/howto/deployment/wsgi/
+"""
+
+import os
+
+from django.core.wsgi import get_wsgi_application
+
+os.environ.setdefault("DJANGO_SETTINGS_MODULE", "ptb_website.settings")
+
+application = get_wsgi_application()

ptb_website/wsgi.py

@@ -0,0 +1,48 @@
+# Import your application as:
+# from wsgi import application
+# Example:
+
+from ptb_website.wsgi import application
+
+# Import CherryPy
+import cherrypy
+
+if __name__ == '__main__':
+
+    # Mount the application
+    cherrypy.tree.graft(application, "/")
+
+    # Unsubscribe the default server
+    cherrypy.server.unsubscribe()
+
+    # Instantiate a new server object
+    server = cherrypy._cpserver.Server()
+
+    # Configure the server object
+    server.socket_host = "87.106.32.46"
+    server.socket_port = 8001
+    server.thread_pool = 10
+
+    # For SSL Support
+    # server.ssl_module            = 'pyopenssl'
+    # server.ssl_certificate       = 'ssl/certificate.crt'
+    # server.ssl_private_key       = 'ssl/private.key'
+    # server.ssl_certificate_chain = 'ssl/bundle.crt'
+
+    # Subscribe this server
+    server.subscribe()
+
+    # Example for a 2nd server (same steps as above):
+    # Remember to use a different port
+
+    # server2             = cherrypy._cpserver.Server()
+
+    # server2.socket_host = "0.0.0.0"
+    # server2.socket_port = 8081
+    # server2.thread_pool = 30
+    # server2.subscribe()
+
+    # Start the server engine (Option 1 *and* 2)
+
+    cherrypy.engine.start()
+    cherrypy.engine.block()

server.py

@@ -0,0 +1,47 @@
+import os
+import cherrypy
+from cherrypy import wsgiserver
+
+from ptb_website import wsgi, settings
+
+from httplogger import HTTPLogger
+
+PATH = os.path.abspath(os.path.dirname(__file__))
+
+
+class Root(object):
+    pass
+
+def make_static_config(static_dir_name):
+    """
+    All custom static configurations are set here, since most are common, it
+    makes sense to generate them just once.
+    """
+    static_path = os.path.join('/', static_dir_name)
+    path = os.path.join(PATH, static_dir_name)
+    configuration = {static_path: {
+        'tools.staticdir.on': True,
+        'tools.staticdir.dir': path}
+    }
+    
+    return cherrypy.tree.mount(Root(), '/', config=configuration)
+
+application = wsgiserver.WSGIPathInfoDispatcher(
+{
+    '/': wsgi.application,
+    settings.STATIC_URL[:-1]: make_static_config(settings.STATIC_URL[1:-1]),
+    settings.MEDIA_URL[:-1]: make_static_config(settings.MEDIA_URL[1:-1])
+})
+    
+cherrypy.config.update({'environment': 'production',
+                'log.error_file': 'site.log',
+                'log.screen': True})
+
+server = wsgiserver.CherryPyWSGIServer(('127.0.0.1', 8001), HTTPLogger(application),
+                                       server_name='python-telegram-bot.org')
+try:
+    server.start()
+except KeyboardInterrupt:
+    print("Terminating server...")
+    server.stop()
+