~joaopinto/apt-portal/pre-modules

#!/usr/bin/env python
# -*- coding: utf-8 -*-
#
#   (C) Copyright 2009, APT-Portal Developers
#    https://launchpad.net/~apt-portal-devs
#
#    This program is free software: you can redistribute it and/or modify
#    it under the terms of the GNU General Public License as published by
#    the Free Software Foundation, either version 3 of the License, or
#    (at your option) any later version.
#
#    This program is distributed in the hope that it will be useful,
#    but WITHOUT ANY WARRANTY; without even the implied warranty of
#    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
#    GNU General Public License for more details.
#
#    You should have received a copy of the GNU General Public License
#    along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

# This is the main server setup code
import cherrypy
import sys
import os
import tempfile
from cherrypy import _cplogging
from elixir import *
from optparse import OptionParser
from cherrypy.lib import cptools
from logging import handlers, DEBUG
from common import sqlalchemy_tool
from common import precontroller
from common.controllers.webroot import Root, RootForce

 
"""
	Set the access logs to be rotated when they reach rot_maxBytes
	keeping a max of rot_backupCount log files
"""
def set_rotating_logs(app, appname, \
		rot_maxBytes = 10000000, rot_backupCount = 1000):
    """ Set rotated logs for app """
    log = app.log
    
    # Create the application logs directory
    logs_dir = "logs/%s" % appname
    if not os.path.exists(logs_dir):
        os.makedirs(logs_dir, 0700)

    # Remove the default FileHandlers if present.
    log.error_file = ""
    log.access_file = ""

    maxBytes = getattr(log, "rot_maxBytes", rot_maxBytes)    
    backupCount = getattr(log, "rot_backupCount", rot_backupCount)

    # Make a new RotatingFileHandler for the error log.
    fname = getattr(log, "rot_error_file", "%s/error.log" % logs_dir)
    h = handlers.RotatingFileHandler(fname, 'a', maxBytes, backupCount)
    h.setLevel(DEBUG)
    h.setFormatter(_cplogging.logfmt)
    log.error_log.addHandler(h)

    # Make a new RotatingFileHandler for the access log.
    fname = getattr(log, "rot_access_file", "%s/access.log" % logs_dir)
    h = handlers.RotatingFileHandler(fname, 'a', maxBytes, backupCount)
    h.setLevel(DEBUG)
    h.setFormatter(_cplogging.logfmt)
    log.access_log.addHandler(h)
 
"""
	Set cherrypy server configuration 
"""  
def set_cherrypy_config(appname, db_url, echo):
	""" Set the cherrypy web server configuration """
	current_dir = os.path.dirname(os.path.abspath(__file__))

	aptportal_threads = int(os.environ.get('APTPORTAL_THREADS', 100))
	
	# Set network related options and optional console log
	cherrypy.config.update({'environment': 'production',
							'server.socket_host': options.host,
							'server.socket_port': int(options.port),
							'server.thread_pool': aptportal_threads,
							'log.screen': options.console_log})
							
	# Enable gzip compression
	cherrypy.config.update({'tools.gzip.on': 'True'})
		
	# Enable sessions support
	if not os.path.isdir('/tmp/cherrypy_sessions_' + appname):
		os.mkdir('/tmp/cherrypy_sessions_' + appname, 0700)	
	cherrypy.config.update({'tools.sessions.on': True \
		, 'tools.sessions.storage_type': "file" \
		, 'tools.sessions.storage_path': "/tmp/cherrypy_sessions_"  + appname \
		, 'tools.sessions.timeout': 60 \
		
	})

	# Set utf8 encoding options
	cherrypy.config.update({'tools.encode.on':True \
		, 'tools.encode.encoding':'utf-8' \
		, 'tools.encode.errors':'replace' \
	})
	
	# Setup SQLAlchemy transaction handler
	cherrypy.config.update({'tools.SATransaction.on' : True \
		, 'tools.SATransaction.dburi' : db_url \
		, 'tools.SATransaction.echo': echo,
	})
	
	# Enable the precontroller tool
	cherrypy.config.update({'tools.precontroller.on': 'True'})
		
	# Setup the application related static content directories
	conf = {'/':   {'tools.staticdir.root': os.path.join(current_dir \
				, 'applications', appname, 'static')} \
			,'/media': { 'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, 'media')}				
		   ,'/images': {'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, 'applications', appname, 'static','images')}
			,'/css': {'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, 'applications', appname, 'static','css')} \
			,'/js': {'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, 'applications', appname, 'static', 'js')} \
				## Common static \
			,'/common/css': {'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, 'common', 'static','css')}
			,'/common/js': {'tools.precontroller.on': False, \
					'tools.staticdir.on': True, \
					'tools.staticdir.dir': os.path.join(current_dir \
				, "common", 'static', 'js')}				
				}
				
	return conf

""" Add an username to the admin group """
def add_admin(username):
		from models.user import User, UsersGroup
		admin_group = UsersGroup.query.filter_by(name = "Admin").first()
		if not admin_group: # if not found create it
			admin_group = UsersGroup(name = "Admin")
		user = User.query.filter_by(username = username).first()
		if not user:
			print "User %s is not registed" % username
			return 2
		if admin_group in user.groups:
			print "User %s is already on the admin group." \
				% username
			return 1
		else: # add it
			user.groups.append(admin_group)		
			user.auth = 1
			session.commit()
			print "User %s added to the admin group." \
				% username
		return 0

""" 
	Returns an option parser object with the available 
	command line parameters
"""	
def command_line_parser():
	parser = OptionParser()
	parser.add_option("-a", "--add-admin",
		action = "store", type="string", dest="add_admin",
		help = "Add an user to the admin group" \
		)        				
	parser.add_option("-b", "--bindip", \
		action = "store", type="string", dest="host", \
		help = "set bind address for the listener (default=127.0.0.1)" \
		, default="127.0.0.1")
	parser.add_option("-d", "--database",
		action = "store", type="string", dest="database",
		help = "specificy the database URI\n\n" \
		"Examples\n\n" \
		"   mysql://user:password@localhost/database" \
		"   sqlite:///database" \
		)        
	parser.add_option("-e", "--daemon", \
		action = "store_true", dest="daemon", default=False, \
		help = "run process as a daemon (background)")		
	parser.add_option("-f", "--force-view", \
		action = "store", type="string", dest="force_view", \
		help = "force a specific view to be server for all requests\n" \
			"Usefull if you need to provide a maintenance warning")
	parser.add_option("-l", "--console-log", \
		action = "store_true", dest="console_log", default=False, \
		help = "print the http log to the console")
	parser.add_option("-p", "--port", \
		action = "store", type="string", dest="port", \
		help = "set bind address for the listener (default=8080)" \
			, default="8080" )                  
	parser.add_option("-s", "--sql-echo", \
		action = "store_true", dest="sql_echo", default=False, \
		help = "echo the sql statements")
	return parser


""" Main code """
if __name__ == '__main__':    
	current_dir = os.path.dirname(os.path.abspath(__file__))

	# We need this for common models import
	commons_dir = os.path.join(current_dir, 'common')
	if not commons_dir in sys.path:
		sys.path.insert(0, commons_dir)            
	import cherrypy_mako
    
    # Get the command line options
	(options, args) = command_line_parser().parse_args()
	if len(args) < 1:
		print "Usage: %s [options]" % os.path.basename(__file__)
		sys.exit(2)
	appname = args[0]
    
	# Check if there is an application on the expected directory
	if not os.path.isdir(os.path.join(current_dir, "applications" \
		, appname)):
		print "No application %s on the applications directory" \
			% appname
		sys.exit(3)
		
	# We set the database engine here
	db_url = options.database or ("sqlite:///%s.db" % appname)
	# stdin is a special url which prompts for the database url
	# this allows to start the process without having the url included
	# on the system command startup arguments
	if db_url == 'stdin': # special case to request from stdin (secure)
		db_url = raw_input('Please enter the db url:')
		print
	metadata.bind = db_url
	metadata.bind.echo = options.sql_echo

    # Handle --add-admin
	if options.add_admin:
		rc = add_admin(options.add_admin)
		sys.exit(rc)
		
	# Set the app server configuration				
	conf = set_cherrypy_config(appname, db_url, metadata.bind.echo)	
	
	# Set rotating logs
	set_rotating_logs(cherrypy, appname)	
	
	# Set directories for the templating engine
	app_dir = os.path.join(current_dir, 'applications', appname)
	cherrypy_mako.set_directories(
		[os.path.join(app_dir,'views') \
			, os.path.join(current_dir, 'common', 'views') \
		] \
		, os.path.join(tempfile.mkdtemp())
		)
	
	
	# Set the web root handler
	# If the force view parameter is used then we need to use a special
	# web root controlller which handles web_root/* unlike the regular
	if options.force_view:
		print "Forcing the template to", options.force_View
		cherrypy.root = RootForce(options.force_view)
	else:
		cherrypy.root = Root()                    
		app_startup_module = os.path.join(app_dir, 'startup.py')
		if os.path.exists(app_startup_module):		
			sys.path.insert(0, app_dir)
			import startup
			sys.path.remove(app_dir)
		
		    
	# Start the server
	cherrypy.quickstart(cherrypy.root, '/', config=conf)