def test_superuser_required_mixin_not_supersuer(self):
"""Test for mixin requiring a superuser when user isn't a superuser."""
self.client.login(username=self.username, password=self.password)
with self.assertRaises(PermissionDenied):
request = WSGIHandler()
request.user = self.user
mixin = SuperuserRequiredViewMixin()
mixin.dispatch(request)
def load(self):
handler = WSGIHandler()
try:
from whitenoise.django import DjangoWhiteNoise
except ImportError:
pass
else:
handler = DjangoWhiteNoise(handler)
media_root, media_prefix = self.get_media_root_and_prefix()
handler.add_files(media_root, prefix=media_prefix)
return handler
def test_staff_required_mixin_is_staff(self, dispatch):
"""Test for mixin requiring a staff user when user is staff."""
dispatch.return_value = 'worked'
self.client.login(username=self.username, password=self.password)
self.user.is_staff = True
request = WSGIHandler()
request.user = self.user
mixin = StaffRequiredViewMixin()
actual_return = mixin.dispatch(request)
self.assertEqual(actual_return, dispatch.return_value)
def benchmark():
req_factory = RequestFactory()
handler = WSGIHandler()
handler.load_middleware()
with_middleware_time = time()
handler.get_response(req_factory.get('/'))
with_middleware_time = time() - with_middleware_time
no_middleware_time = time()
index(req_factory.get('/'))
no_middleware_time = time() - no_middleware_time
return with_middleware_time - no_middleware_time
def render_jade_with_json(self, jade_template_path, json_file_path,
template_path_base, base_file):
logger.debug('Working with jade template %s', jade_template_path)
tmpl = loader.get_template(jade_template_path)
if settings.DEBUG:
logger.debug('Template is: %s',
process(open(os.path.join(self.template_path,
jade_template_path)).read()))
# We need to simulate request middleware but without short-circuiting
# the response
request_factory = RequestFactory()
req = request_factory.get('/%s/%s.html' % (template_path_base,
base_file),
data={})
handler = WSGIHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
middleware_method(req)
# Render the template with a RequestContext
ctx = RequestContext(req, json.load(open(json_file_path)))
return tmpl.render(ctx)
def mock(self, base_file_name, path, template_path):
html_template_path = os.path.join(self.app.replace('.', '/'),
'%s.html' % (base_file_name,))
json_file_path = os.path.join(path, '%s.json' % (base_file_name,))
tmpl = loader.get_template(html_template_path)
# We need to simulate request middleware but without short-circuiting
# the response
request_factory = RequestFactory()
req = request_factory.get('/%s' % (html_template_path,),
data={})
handler = WSGIHandler()
handler.load_middleware()
for middleware_method in handler._request_middleware:
middleware_method(req)
# Render the template with a RequestContext
ctx = RequestContext(
req,
json.load(open(json_file_path),
object_hook=lambda d: DictWithSpecialUnicode(d)))
logger.debug('Updating context with base context %s', self.base_context)
ctx.update(self.base_context)
return tmpl.render(ctx)
def benchmark():
req_factory = RequestFactory()
handler = WSGIHandler()
# Try first with Django's default middleware
settings.MIDDLEWARE_CLASSES = global_settings.MIDDLEWARE_CLASSES
handler.load_middleware()
with_middleware_time = time()
handler.get_response(req_factory.get('/'))
with_middleware_time = time() - with_middleware_time
# Now try the same process, but this time without any middleware.
settings.MIDDLEWARE_CLASSES = []
handler.load_middleware()
no_middleware_time = time()
handler.get_response(req_factory.get('/'))
no_middleware_time = time() - no_middleware_time
return with_middleware_time - no_middleware_time
def setup():
global req_factory, handler_default_middleware, handler_no_middleware
req_factory = RequestFactory()
settings.MIDDLEWARE_CLASSES = global_settings.MIDDLEWARE_CLASSES
handler_default_middleware = WSGIHandler()
handler_default_middleware.load_middleware()
settings.MIDDLEWARE_CLASSES = []
handler_no_middleware = WSGIHandler()
handler_no_middleware.load_middleware()
def setup():
global req_factory, handler_default_middleware, handler_no_middleware
req_factory = RequestFactory()
use_MIDDLEWARE_setting = True
try:
settings.MIDDLEWARE = global_settings.MIDDLEWARE
except AttributeError:
settings.MIDDLEWARE_CLASSES = global_settings.MIDDLEWARE_CLASSES
use_MIDDLEWARE_setting = False
handler_default_middleware = WSGIHandler()
handler_default_middleware.load_middleware()
if use_MIDDLEWARE_setting:
settings.MIDDLEWARE = []
else:
settings.MIDDLEWARE_CLASSES = []
handler_no_middleware = WSGIHandler()
handler_no_middleware.load_middleware()
"""
WSGI config for beefun 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/2.1/howto/deployment/wsgi/
"""
import os, sys, django
from django.core.wsgi import get_wsgi_application
from django.core.handlers.wsgi import WSGIHandler
import importlib
importlib.reload(sys)
# sys.setdefaultencoding('utf-8')
os.environ.setdefault(
"DJANGO_SETTINGS_MODULE",
"beefun.settings") #变量testproject.settings为django项目下的settings
django.setup() #避免在虚拟环境下找不到django的app
application = WSGIHandler(
) #实例化一个WSGI application用作接受nginx服务器传递的envrion、start_response参数
def get_wsgi_handler(self):
return StaticFilesHandler(WSGIHandler())
# absolute path to the myproject directory
PROJECT_PATH = os.path.realpath(os.path.dirname(__file__))
# absolute path to myproject/src
PROJECT_SRC_PATH = os.path.join(PROJECT_PATH, PROJECT_SRC_NAME)
# absolute path to the myproject/src/apps directory
PROJECT_APPS_PATH = os.path.join(PROJECT_SRC_PATH, 'apps')
# lop off myproject name, get the environment name
os.environ['DJANGO_SETTINGS_MODULE'] = '%s.conf.settings' % PROJECT_SRC_NAME
os.environ['PYTHON_EGG_CACHE'] = '/tmp'
# check that the project module can be imported.
try:
__import__(PROJECT_SRC_NAME)
except ImportError:
# couldn't import the project, place it on the python path and try again.
sys.path.insert(0, PROJECT_PATH)
try:
__import__(PROJECT_SRC_NAME)
except ImportError:
sys.stderr.write("Error: Can't import the \"%s\" project module." %
PROJECT_SRC_NAME)
sys.path.insert(0, PROJECT_SRC_PATH)
sys.path.insert(0, PROJECT_APPS_PATH)
# finally.. define the WSGI handler as the entry point to the application
application = Sentry(WSGIHandler())
def inner_run():
# Flag the server as active
from devserver import settings
import devserver
settings.DEVSERVER_ACTIVE = True
settings.DEBUG = True
from django.conf import settings
from django.utils import translation
print "Validating models..."
self.validate(display_num_errors=True)
print "\nDjango version %s, using settings %r" % (
django.get_version(), settings.SETTINGS_MODULE)
print "Running django-devserver %s" % (devserver.get_version(), )
if use_werkzeug:
server_type = 'werkzeug'
else:
server_type = 'django'
print "%s %s server is running at http://%s:%s/" % (
options['use_forked'] and 'Forked'
or 'Threaded', server_type, addr, port)
print "Quit the server with %s." % quit_command
# django.core.management.base forces the locale to en-us. We should
# set it up correctly for the first request (particularly important
# in the "--noreload" case).
translation.activate(settings.LANGUAGE_CODE)
if int(options['verbosity']) < 1:
app = WSGIHandler()
else:
app = DevServerHandler()
if wsgi_app:
print "Using WSGI application %r" % wsgi_app
if os.path.exists(os.path.abspath(wsgi_app)):
# load from file
app = imp.load_source(
'wsgi_app', os.path.abspath(wsgi_app)).application
else:
try:
app = __import__(wsgi_app, {}, {},
['application']).application
except (ImportError, AttributeError):
raise
if options['use_forked']:
mixin = SocketServer.ForkingMixIn
else:
mixin = SocketServer.ThreadingMixIn
middleware = getattr(settings, 'DEVSERVER_WSGI_MIDDLEWARE', [])
for middleware in middleware:
module, class_name = middleware.rsplit('.', 1)
app = getattr(__import__(module, {}, {}, [class_name]),
class_name)(app)
if 'django.contrib.staticfiles' in settings.INSTALLED_APPS and use_static_files:
from django.contrib.staticfiles.handlers import StaticFilesHandler
app = StaticFilesHandler(app)
else:
app = AdminMediaHandler(app, admin_media_path)
if options['use_dozer']:
from dozer import Dozer
app = Dozer(app)
try:
if use_werkzeug:
run_simple(addr,
int(port),
DebuggedApplication(app, True),
use_reloader=False,
use_debugger=True)
else:
run(addr, int(port), app, mixin)
except WSGIServerException, e:
# Use helpful error messages instead of ugly tracebacks.
ERRORS = {
13: "You don't have permission to access that port.",
98: "That port is already in use.",
99: "That IP address can't be assigned-to.",
}
try:
error_text = ERRORS[e.args[0].args[0]]
except (AttributeError, KeyError):
error_text = str(e)
sys.stderr.write(
self.style.ERROR("Error: %s" % error_text) + '\n')
# Need to use an OS exit because sys.exit doesn't work in a thread
os._exit(1)
#-*- coding:utf-8 -*-
import os
import sys
os.environ['DJANGO_SETTINGS_MODULE'] = 'Warrentech_FontCenter_Web.settings'
path = os.path.dirname(
os.path.abspath(__file__)) + '/Warrentech_FontCenter_Web'
if path not in sys.path:
sys.path.insert(1, path)
from django.core.handlers.wsgi import WSGIHandler
from bae.core.wsgi import WSGIApplication
application = WSGIApplication(WSGIHandler())
# -*- coding: utf-8 -*-
"""
Copyright (C) 2013 Dariusz Suchojad <dsuch at zato.io>
Licensed under LGPLv3, see LICENSE.txt for terms and conditions.
"""
# stdlib
import os, sys
from wsgiref.simple_server import make_server
# Django
from django.core.handlers.wsgi import WSGIHandler
settings_dir = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, settings_dir)
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
app = WSGIHandler()
make_server('127.0.0.1', 8188, app).serve_forever()
def run(self):
self.lock.acquire()
pidfile = os.path.join(tempfile.gettempdir(), 'lettuce-django.pid')
if os.path.exists(pidfile):
pid = open(pidfile).read()
if pid:
pid = int(pid)
try:
os.kill(pid, 9)
except OSError:
pass
finally:
os.unlink(pidfile)
open(pidfile, 'w').write(str(os.getpid()))
self.configure_mail_queue()
connector = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
if self.threading:
httpd_cls = type(str('WSGIServer'),
(socketserver.ThreadingMixIn, WSGIServer), {})
else:
httpd_cls = WSGIServer
try:
s = connector.connect((self.address, self.port))
self.lock.release()
os.kill(os.getpid(), 9)
except socket.error:
pass
finally:
self.lock.release()
try:
server_address = (self.address, self.port)
httpd = httpd_cls(server_address, MutedRequestHandler)
except socket.error:
raise LettuceServerException(
"the port %d already being used, could not start " \
"django's builtin server on it" % self.port,
)
handler = WSGIHandler()
if self.should_serve_admin_media():
if not AdminMediaHandler:
raise LettuceServerException(
"AdminMediaHandler is not available in this version of "
"Django. Please set LETTUCE_SERVE_ADMIN_MEDIA = False "
"in your Django settings.")
admin_media_path = ''
handler = AdminMediaHandler(handler, admin_media_path)
if self.should_serve_static_files():
handler = StaticFilesHandler(handler)
httpd.set_app(handler)
global keep_running
while keep_running:
call_hook('before', 'handle_request', httpd, self)
httpd.handle_request()
call_hook('after', 'handle_request', httpd, self)
try:
self.lock.release()
except ValueError:
pass
def make_wsgi(req):
# twisted.web2 can not insert 'PATH_INFO' into environment.
os.environ["PATH_INFO"] = req.path
os.environ["SCRIPT_URL"] = req.path
return wsgi.WSGIResource(AdminMediaHandler(WSGIHandler()))
# web_nutrition: a web based nutrition and diet analysis program.
# Copyright (C) 2008 Edgar Denny
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero 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 Affero General Public License for more details.
# You should have received a copy of the GNU Affero General Public License
# along with this program. If not, see <http://www.gnu.org/licenses/>.
from wsgiref.simple_server import make_server
from django.core.handlers.wsgi import WSGIHandler
httpd = make_server('', 8000, WSGIHandler())
httpd.serve_forever()
def run(self):
super(Service, self).run()
self.amqp_tx_forwarder = AmqpTxForwarder(self.queues)
self.amqp_rx_forwarder = AmqpRxForwarder(self.queues)
# This thread listens to an AMQP queue and appends incoming messages
# to queues for retransmission to agents
tx_svc_thread = ServiceThread(self.amqp_tx_forwarder)
# This thread listens to local queues and appends received messages
# to an AMQP queue
rx_svc_thread = ServiceThread(self.amqp_rx_forwarder)
rx_svc_thread.start()
tx_svc_thread.start()
# FIXME: this TERMINATE_ALL format could in principle
# be passed back from the agent (but it should never
# originate there), affecting sessions for other agents.
# At restart, message receiving services to clear out any
# existing session state (from a previous instance of this
# service).
for plugin in ['action_runner']:
self.queues.receive({
'fqdn': None,
'type': 'SESSION_TERMINATE_ALL',
'plugin': plugin,
'session_id': None,
'session_seq': None,
'body': None
})
# This thread services session management RPCs, so that other
# services can explicitly request a session reset
session_rpc_thread = ServiceThread(HttpAgentRpc(self))
session_rpc_thread.start()
# Hook up the request handler
MessageView.queues = self.queues
MessageView.sessions = self.sessions
MessageView.hosts = self.hosts
ValidatedClientView.valid_certs = self.valid_certs
# The thread for generating HostOfflineAlerts
host_checker_thread = ServiceThread(
HostStatePoller(self.hosts, self.sessions))
host_checker_thread.start()
# The main thread serves incoming requests to exchanges messages
# with agents, until it is interrupted (gevent handles signals for us)
self.server = gevent.wsgi.WSGIServer(('', HTTP_AGENT_PORT),
WSGIHandler())
self.server.serve_forever()
session_rpc_thread.stop()
tx_svc_thread.stop()
rx_svc_thread.stop()
host_checker_thread.stop()
session_rpc_thread.join()
tx_svc_thread.join()
tx_svc_thread.join()
host_checker_thread.join()
def lambda_handler(event, context):
"""
An AWS Lambda function which parses specific API Gateway input into a WSGI request,
feeds it to Django, procceses the Django response, and returns that
back to the API Gateway.
"""
# Django requires settings and an explicit call to setup()
# if being used from inside a python context.
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "zappa_settings")
import django
django.setup()
from django.conf import settings
# This is a normal HTTP request
if event.get('method', None):
# If we just want to inspect this,
# return this event instead of processing the request
# https://your_api.aws-api.com/?event_echo=true
event_echo = getattr(settings, "EVENT_ECHO", True)
if event_echo:
if 'event_echo' in event['params'].values():
return {
'Content': str(event) + '\n' + str(context),
'Status': 200
}
# This doesn't matter, but Django's handler requires it.
def start(a, b):
return
# Create the environment for WSGI and handle the request
environ = create_wsgi_request(event, script_name=settings.SCRIPT_NAME)
handler = WSGIHandler()
response = handler(environ, start)
# Prepare the special dictionary which will be returned to the API GW.
returnme = {'Content': response.content}
# Pack the WSGI response into our special dictionary.
for item in response.items():
returnme[item[0]] = item[1]
returnme['Status'] = response.status_code
# Parse the WSGI Cookie and pack it.
cookie = response.cookies.output()
if ': ' in cookie:
returnme['Set-Cookie'] = response.cookies.output().split(': ')[1]
# To ensure correct status codes, we need to
# pack the response as a deterministic B64 string and raise it
# as an error to match our APIGW regex.
# The DOCTYPE ensures that the page still renders in the browser.
if response.status_code in [400, 401, 403, 500]:
content = response.content
content = "<!DOCTYPE html>" + str(
response.status_code) + response.content
b64_content = base64.b64encode(content)
raise Exception(b64_content)
# Internal are changed to become relative redirects
# so they still work for apps on raw APIGW and on a domain.
elif response.status_code in [301, 302]:
location = returnme['Location']
location = '/' + location.replace("http://zappa/", "")
raise Exception(location)
else:
return returnme
# This is a management command invocation.
elif event.get('command', None):
from django.core import management
# Couldn't figure out how to get the value into stdout with StringIO..
# Read the log for now. :[]
management.call_command(*event['command'].split(' '))
return {}
import sys, os
sys.path.append(os.getcwd())
sys.path.append(os.getcwd() + '/huxley')
INTERP = os.path.join(os.getcwd(), 'env/bin/python')
if sys.executable != INTERP: os.execl(INTERP, INTERP, *sys.argv)
sys.path.insert(0, os.path.join(os.getcwd(), 'env/bin'))
sys.path.insert(
0, os.path.join(os.getcwd(), 'env/lib/python2.7/site-packages/django'))
sys.path.insert(0, os.path.join(os.getcwd(),
'env/lib/python2.7/site-packages'))
os.environ['DJANGO_SETTINGS_MODULE'] = "huxley.settings"
import django
django.setup()
from django.core.handlers.wsgi import WSGIHandler
from paste.exceptions.errormiddleware import ErrorMiddleware
application = ErrorMiddleware(WSGIHandler(), debug=True)
def test_middleware_initialized(self):
handler = WSGIHandler()
self.assertIsNotNone(handler._middleware_chain)
def start_server_servestatic(self, options):
"""
Start CherryPy server AND serve default static files
Want SSL support?
a. The new (3.1 or 3.2) way: Just set server.ssl_adapter to an SSLAdapter instance.
b. The old way (deprecated way) is to set these attributes:
server.ssl_certificate = <filename>
server.ssl_private_key = <filename>
But this is the only way from the management command line
in the future I may need to adapt this to use a server.ssl_adapter
"""
# debug?
# print "options:"
from django.conf import settings
quit_command = (sys.platform
== 'win32') and 'CTRL-BREAK' or 'CONTROL-C'
self.stdout.write("Validating models..")
self.validate(display_num_errors=True)
self.stdout.write(
("%(started_at)s\n"
"Django version %(version)s, using settings %(settings)r\n"
"cherrypy django_wsgiserver is running at http://%(addr)s:%(port)s/\n"
"Quit the server with %(quit_command)s.\n") %
{
"started_at": datetime.now().strftime('%B %d, %Y - %X'),
"version": self.get_version(),
"settings": settings.SETTINGS_MODULE,
"addr": options[
'host'], # self._raw_ipv6 and '[%s]' % self.addr or self.addr,
"port": options['port'],
"quit_command": quit_command,
})
#logger.info("launching wsgiserver with the following options")
#logger.info(pformat(options))
if int(options['verbose']) >= 2:
self.stdout.write("launching with the following options:\n")
self.stdout.write(pformat(options))
if options['daemonize'] and options['server_user'] and options[
'server_group']:
#ensure the that the daemon runs as specified user
change_uid_gid(options['server_user'], options['server_group'])
from django_wsgiserver.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
#from cherrypy.wsgiserver import CherryPyWSGIServer, WSGIPathInfoDispatcher
from django.core.handlers.wsgi import WSGIHandler
from django.conf import settings
app = WSGIHandler() # serve the django content
path = {
'/': app
} # well will build up the serving url routing path below
# Now work on serving the static content
# note as of django 1.4, ADMIN_MEDIA_PREFIX is depreciated and instead uses django.contrib.staticfiles
# so it is not an error for ADMIN_MEDIA_PREFIX to not be defined, I will test to see if exists
# and print a warning that adminserve is activated but it's not defined.
# so for django 1.4 (or 1.5 ?) staticserve=True => adminserve=True
# so the choices
# There are basically two ways for statics to be served
# 1. in development, one often wants each application's static files to be served from within its file structure
# this is what the django runserver dose
# 2. in production usually, all the static files are collected into a common storage region (files, S3, CDN) and a good webserver
# serve them from there
# deprecated
# if options['adminserve']: # serve the admin media too
# # AdminMediaHandler is middleware for local use
# #import django.core.servers.basehttp
# #adminapp = django.core.servers.basehttp.AdminMediaHandler(app)
# # another way to serve the admin media three application
# if settings.__dict__.has_key('ADMIN_MEDIA_PREFIX'):
# import django.contrib.admin
# path[settings.ADMIN_MEDIA_PREFIX] = django_wsgiserver.mediahandler.StaticFileWSGIApplication(
# os.path.join( django.contrib.admin.__path__[0], 'media'))
# else:
# print "Warning adminserve was selected BUT ADMIN_MEDIA_PREFIX was not defined"
if options['staticserve']:
try:
if not settings.STATIC_URL or not settings.STATIC_ROOT:
# could use misconfigured exception (what is this in django) instead of AttributeError
raise AttributeError, "settings.STATIC_URL = %s, settings.STATIC_ROOT=%s" % (
repr(settings.STATIC_URL), repr(settings.STATIC_ROOT))
except AttributeError, msg:
logger.error(msg)
logger.error("****")
logger.error(
"STATIC_URL and STATIC_ROOT must be set in settings file for staticserve option to work in django_wsgiserver"
)
logger.error("****")
raise
if options['staticserve'] != 'collectstatic':
if settings.STATICFILES_FINDERS: # find the apps' static files and add them to the path
logger.debug("see settings.STATICFILES_FINDERS")
logger.debug(pformat(settings.STATICFILES_FINDERS))
from django.contrib.staticfiles.finders import AppDirectoriesFinder
app_static_finder = AppDirectoriesFinder(
settings.INSTALLED_APPS)
logger.debug("app_static_finder.storages:")
logger.debug(pformat(app_static_finder.storages))
for key, val in app_static_finder.storages.items():
logger.debug(key, " static location:", val.location)
# need to decide what to do with this in terms of the fusion of the app static directories
app_url = key.split('.')[
-1] + r'/' # I'm not sure if it needs the end '/'
full_static_url = os.path.join(settings.STATIC_URL,
app_url)
full_dir_location = os.path.join(val.location, app_url)
logger.debug(full_static_url, full_dir_location)
path[
full_static_url] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
full_dir_location)
if options['servestaticdirs'] and hasattr(settings,
'STATICFILES_DIRS'):
staticlocations = process_staticfiles_dirs(
settings.STATICFILES_DIRS)
# debug !!!
logger.debug("staticlocations::")
logger.debug(pformat(staticlocations))
for urlprefix, root in staticlocations:
path[os.path.join(
settings.STATIC_URL, urlprefix
)] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
root)
# One important thing is that there are two different ways to serve the static files
# 1. convenient: serve each app's static files (assuming they follow convention)
# 2. do a collectstatic and serve from that node -- likely this would be done more in a "production" scenario
if options['staticserve'] == 'collectstatic':
# and serve the root of the STATIC_URL ? hmm !!!
path[
settings.
STATIC_URL] = django_wsgiserver.wsgiutil.StaticFileWSGIApplication(
settings.STATIC_ROOT)
logger.warning(
"serving all static files from %s. *** Make sure you have done a fresh collectstatic operation ***"
% settings.STATIC_ROOT)
def get_wsgi_application():
django.setup()
return WSGIHandler()
#-*- coding:utf-8 -*-
import os
import sys
path = os.path.dirname(os.path.abspath(__file__)).replace('\\',
'/') + '/urlhandler'
if path not in sys.path:
sys.path.insert(1, path)
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "urlhandler.settings")
from django.core.handlers.wsgi import WSGIHandler
django_WSGI = WSGIHandler()
from queryhandler import handle_weixin_request
from settings import LUCKY_URL
from queryhandler.settings import SITE_DOMAIN, SITE_HTTP_PROTOCOL
def app(environ, start_response):
update_site_domain(environ.get('HTTP_HOST', ''))
if environ.get('PATH_INFO', '') == LUCKY_URL:
result = handle_weixin_request(environ)
status = '200 OK'
headers = [('Content-type', 'text/html')]
start_response(status, headers)
#print result
return [result.encode('utf8')]
else:
#status = '200 OK'
def get_wsgi_handler(self):
return DjangoWsgiFix(StaticFilesHandler(WSGIHandler()))
class Command(BaseCommand):
option_list = BaseCommand.option_list + (
make_option(
'--numthreads',
dest='numthreads',
default='30',
help=
'Specifies the number of worker threads to create. Defaults to 30 threads.'
),
make_option('--daemonize',
dest='daemonize',
action='store_true',
help='Runs the Web server in the background.'),
make_option(
'--workdir',
dest='workdir',
default='.',
help=
'Work directory to change to before daemonizing. Defaults to the current directory.'
),
make_option('--pidfile',
dest='pidfile',
default='',
help='Specifies the file in which to write the PID.'),
make_option(
'--urlpath',
dest='urlpath',
default='/',
help=
'Specifies the URL path prefix to which the Web server responds. Defaults to /'
),
make_option(
'--servername',
dest='servername',
help=
"The string to set for WSGI's SERVER_NAME environment variable."),
)
help = """Runs the Django application under CherryPy's production quality Web server.
Requires CherryPy WSGIServer.
WARNING: This DOES NOT serve static media files.
"""
args = '[optional port number, or ipaddr:port (defaults to 127.0.0.1:8000)]'
def handle(self, addrport='', *args, **options):
import django
from django.core.handlers.wsgi import WSGIHandler
if args:
raise CommandError('Usage is runhttp %s' % self.args)
if not addrport:
addr = ''
port = '8000'
else:
try:
addr, port = addrport.split(':')
except ValueError:
addr, port = '', addrport
if not addr:
addr = '127.0.0.1'
if not port.isdigit():
raise CommandError("%r is not a valid port number." % port)
numthreads = options.get('numthreads', '30')
if not numthreads.isdigit():
raise CommandError("%r is not a valid value for numthreads." %
numthreads)
port = int(port)
numthreads = int(numthreads)
print "Starting %s threads" % numthreads
try:
from cherrypy.wsgiserver import CherryPyWSGIServer
from cherrypy.wsgiserver import WSGIPathInfoDispatcher
except ImportError:
try:
from wsgiserver import CherryPyWSGIServer
from wsgiserver import WSGIPathInfoDispatcher
except ImportError, e:
print >> sys.stderr, "ERROR: %s" % e
print >> sys.stderr, " Unable to load the wsgiserver package. In order to run django's"
print >> sys.stderr, " high-performance web server, you will need to get wsgiserver from"
print >> sys.stderr, " http://svn.cherrypy.org/trunk/cherrypy/"
print >> sys.stderr, " Only the wsgiserver directory and its contents are required."
print >> sys.stderr, " If you've already installed wsgiserver, "
print >> sys.stderr, " make sure it is in your PYTHONPATH."
return False
#print "Validating models..."
self.validate(display_num_errors=False)
wsgi_apps = WSGIPathInfoDispatcher([(options.get('urlpath',
'/'), WSGIHandler())])
server = CherryPyWSGIServer(
(addr, port),
wsgi_apps,
numthreads=numthreads,
server_name=options.get('servername', None))
daemonize = options.get('daemonize', False)
if daemonize:
from django.utils.daemonize import become_daemon
workdir = options.get('workdir', '.')
become_daemon(our_home_dir=workdir)
else:
print "HTTP server started on %s:%s" % (addr, port)
print "Press Ctrl-C to stop the server."
if options.get("pidfile", False):
fp = open(options["pidfile"], "w")
fp.write("%d\n" % os.getpid())
fp.close()
try:
server.start()
except (KeyboardInterrupt, SystemExit):
server.stop()
def runserver(environ, start_response):
if ws_connector(environ) != True:
# If environment is not WebSocket, then call django server
setup_environ(settings)
application = DjangoWSGIApp()
return application.__call__(environ, start_response)
def Run(self):
# Import modules
from cheroot import wsgi
from subprocess import call, DEVNULL
from win32process import DETACHED_PROCESS, CREATE_NO_WINDOW
# Initialize django
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "freppledb.settings")
os.environ.setdefault("FREPPLE_APP",
os.path.join(sys.path[0], "custom"))
import django
django.setup()
from django.conf import settings
from django.core.handlers.wsgi import WSGIHandler
from django.contrib.staticfiles.handlers import StaticFilesHandler
# Override the debugging settings
settings.DEBUG = False
settings.TEMPLATE_DEBUG = False
# Sys.path contains the zip file with all packages. We need to put the
# application directory into the path as well.
sys.path += [os.environ["FREPPLE_APP"]]
# Append all output to a unbuffered log stream
with open(os.path.join(settings.FREPPLE_LOGDIR, "service.log"),
"a") as logfile:
sys.stderr = sys.stdout = logfile
try:
# Using the included postgres database
# Check if the database is running. If not, start it.
if os.path.exists(
os.path.join(settings.FREPPLE_HOME, "..", "pgsql",
"bin", "pg_ctl.exe")):
status = call(
[
os.path.join(
settings.FREPPLE_HOME,
"..",
"pgsql",
"bin",
"pg_ctl.exe",
),
"--pgdata",
os.path.join(settings.FREPPLE_LOGDIR, "database"),
"--silent",
"status",
],
stdin=DEVNULL,
stdout=DEVNULL,
stderr=DEVNULL,
creationflags=CREATE_NO_WINDOW,
)
if status:
print(
"%s\tStarting the PostgreSQL database" %
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
flush=True,
)
call(
[
os.path.join(
settings.FREPPLE_HOME,
"..",
"pgsql",
"bin",
"pg_ctl.exe",
),
"--pgdata",
os.path.join(settings.FREPPLE_LOGDIR,
"database"),
"--log",
os.path.join(settings.FREPPLE_LOGDIR,
"database", "server.log"),
"start",
],
stdin=DEVNULL,
stdout=DEVNULL,
stderr=DEVNULL,
creationflags=DETACHED_PROCESS,
)
# Prepare web server
self.server = wsgi.Server((settings.ADDRESS, settings.PORT),
StaticFilesHandler(WSGIHandler()))
# Synchronize the scenario table with the settings
from freppledb.common.models import Scenario
Scenario.syncWithSettings()
# Infinite loop serving requests
# The loop gets interrupted when the service gets ordered to shut down.
print(
"%s\tfrePPLe web server listening on http://%s:%d" % (
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
settings.ADDRESS,
settings.PORT,
),
flush=True,
)
self.server.start()
print(
"%s\tStopping service" %
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
flush=True,
)
# Using the included postgres database?
if os.path.exists(
os.path.join(settings.FREPPLE_HOME, "..", "pgsql",
"bin", "pg_ctl.exe")):
# Check if the database is running. If so, stop it.
os.environ["PATH"] = (os.path.join(settings.FREPPLE_HOME,
"..", "pgsql", "bin") +
os.pathsep + os.environ["PATH"])
status = call(
[
os.path.join(
settings.FREPPLE_HOME,
"..",
"pgsql",
"bin",
"pg_ctl.exe",
),
"--pgdata",
os.path.join(settings.FREPPLE_LOGDIR, "database"),
"--silent",
"status",
],
stdin=DEVNULL,
stdout=DEVNULL,
stderr=DEVNULL,
creationflags=CREATE_NO_WINDOW,
)
if not status:
print(
"%s\tShutting down the database" %
datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
flush=True,
)
call(
[
os.path.join(
settings.FREPPLE_HOME,
"..",
"pgsql",
"bin",
"pg_ctl.exe",
),
"--pgdata",
os.path.join(settings.FREPPLE_LOGDIR,
"database"),
"--log",
os.path.join(settings.FREPPLE_LOGDIR,
"database", "server.log"),
"-w", # Wait till it's down
"stop",
],
stdin=DEVNULL,
stdout=DEVNULL,
stderr=DEVNULL,
creationflags=CREATE_NO_WINDOW,
)
# Notify the manager
self.stopEvent.set()
except Exception as e:
print(
"%s\tfrePPLe web server failure: %s" %
(datetime.now().strftime("%Y-%m-%d %H:%M:%S"), e),
flush=True,
)
def runwsgi():
sys.path.append('/var/app/weibonews/enabled/wechat/')
sys.path.append('/var/app/weibonews/enabled/wechat/wechat')
os.environ['DJANGO_SETTINGS_MODULE'] = 'wechat.settings'
got_request_exception.connect(exception_printer)
WSGIServer(('', 8088), WSGIHandler()).serve_forever()
def __init__(self):
self.app = WSGIHandler()
self.factory = DjangoRequestFactory()
def _twill_setup():
app = StaticFilesHandler(WSGIHandler())
twill.add_wsgi_intercept("127.0.0.1", 8080, lambda: app)
"""
Alternative WSGI entry-point that uses requirements/vendor for
dependencies.
"""
import os
import sys
base_dir = os.path.dirname(
os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
sys.path.insert(0, base_dir)
from moztrap.deploy.paths import add_vendor_lib
add_vendor_lib()
# Set default settings and instantiate application
os.environ.setdefault("DJANGO_SETTINGS_MODULE", "moztrap.settings.default")
from django.core.handlers.wsgi import WSGIHandler
application = WSGIHandler()
def json_serve_thread():
from wsgiref.simple_server import make_server
from django.core.handlers.wsgi import WSGIHandler
http = make_server('', 8999, WSGIHandler())
http.serve_forever()
sys.path.append("mydjangosite")
os.environ['DJANGO_SETTINGS_MODULE'] = 'mydjangosite.settings'
from django.core.handlers.wsgi import WSGIHandler
# Twisted Application Framework setup:
application = service.Application('twisted-django')
# WSGI container for Django, combine it with twisted.web.Resource:
# XXX this is the only 'ugly' part: see the 'getChild' method in twresource.Root
# The MultiService allows to start Django and Twisted server as a daemon.
multi = service.MultiService()
pool = threadpool.ThreadPool()
tps = ThreadPoolService(pool)
tps.setServiceParent(multi)
resource = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler())
root = twresource.Root(resource)
# Servce Django media files off of /media:
mediasrc = static.File(os.path.join(os.path.abspath("."),
"mydjangosite/media"))
staticsrc = static.File(
os.path.join(os.path.abspath("."), "mydjangosite/static"))
root.putChild("media", mediasrc)
root.putChild("static", staticsrc)
# The cool part! Add in pure Twisted Web Resouce in the mix
# This 'pure twisted' code could be using twisted's XMPP functionality, etc:
root.putChild("google", twresource.GoogleResource())
# Serve it up:
def get_app(self):
from django.contrib.staticfiles.handlers import StaticFilesHandler
from django.core.handlers.wsgi import WSGIHandler
app = StaticFilesHandler(WSGIHandler())
return app
def handle(self, **options):
# Determine the port number
if 'port' in options:
port = int(options['port'] or settings.PORT)
else:
port = settings.PORT
# Determine the number of threads
if 'threads' in options:
threads = int(options['threads'] or 25)
if threads < 1:
raise Exception("Invalid number of threads: %s" % threads)
else:
threads = 25
# Determine the IP-address to listen on:
# - either as command line argument
# - either 0.0.0.0 by default, which means all active IPv4 interfaces
address = 'address' in options and options['address'] or '0.0.0.0'
# Validate the address and port number
try:
s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
s.bind((address, port))
s.close()
except socket.error as e:
raise Exception("Invalid address '%s' and/or port '%s': %s" %
(address, port, e))
# Print a header message
hostname = socket.getfqdn()
print('Starting frePPLe %s web server\n' % VERSION)
print(
'To access the server, point your browser to either of the following URLS:'
)
if address == '0.0.0.0':
print(' http://%s:%s/' % (hostname, port))
for ip in socket.gethostbyname_ex(socket.gethostname())[2]:
print(' http://%s:%s/' % (ip, port))
else:
print(' http://%s:%s/' % (address, port))
print(
'\nThree users are created by default: "admin", "frepple" and "guest" (the default password is equal to the user name)\n'
)
print('Quit the server with CTRL-C.\n')
# Start a separate thread that will check for updates
# We don't wait for it to finish
CheckUpdates().start()
# Run the WSGI server
server = CherryPyWSGIServer((address, port),
StaticFilesHandler(WSGIHandler()),
numthreads=threads)
# Want SSL support? Just set these attributes apparently, but I haven't tested or verified this
# server.ssl_certificate = <filename>
# server.ssl_private_key = <filename>
try:
server.start()
except KeyboardInterrupt:
server.stop()
def start():
#NOTE bots is always on PYTHONPATH!!! - otherwise it will not start.
#********command line arguments**************************
configdir = 'config'
for arg in sys.argv[1:]:
if not arg:
continue
if arg.startswith('-c'):
configdir = arg[2:]
if not configdir:
print 'Configuration directory indicated, but no directory name.'
sys.exit(1)
elif arg in ["?", "/?"] or arg.startswith('-'):
showusage()
else:
showusage()
#init general: find locating of bots, configfiles, init paths etc.***********************
botsinit.generalinit(configdir)
#init cherrypy; only needed for webserver. *********************************************
cherrypy.config.update({'global': { 'tools.staticdir.root': botsglobal.ini.get('directories','botspath'),
'server.socket_host' : "0.0.0.0", #to what IP addresses should be server. 0.0.0.0: all. See cherrypy docs
'server.socket_port': botsglobal.ini.getint('webserver','port',8080),
'server.environment': botsglobal.ini.get('webserver','environment','development'), # development production
'log.screen': False,
#~ 'log.error_file': '', #set later to rotating log file
#~ 'log.access_file': '', #set later to rotating log file
}})
conf = {'/': {'tools.staticdir.on' : True,'tools.staticdir.dir' : 'media' }}
#~ '/favicon.ico': {'tools.staticfile.on': True,'tools.staticfile.filename': '/home/hje/botsup-django/bots/media/images/favicon.ico'}}
cherrypy.tree.graft(AdminMediaHandler(WSGIHandler()), '/')
myroot = Root()
myappl = cherrypy.tree.mount(myroot, '/media', conf) #myappl is needed to set logging
botsglobal.logger = logging.getLogger('webserver')
botsglobal.logger.setLevel(logging.DEBUG)
h = logging.handlers.TimedRotatingFileHandler(botslib.join(botsglobal.ini.get('directories','logging'),'webserver.log'),when='midnight', backupCount=10)
fileformat = logging.Formatter("%(asctime)s %(levelname)-8s %(name)s : %(message)s",'%Y%m%d %H:%M:%S')
h.setFormatter(fileformat)
# add rotating file handler to main logger
botsglobal.logger.addHandler(h)
# Make RotatingFileHandler for the error log.
#~ h = logging.handlers.TimedRotatingFileHandler(botslib.join(botsglobal.ini.get('directories','logging'),'webserver.log'),when='midnight', backupCount=10)
#~ fileformat = logging.Formatter("%(asctime)s %(levelname)-8s %(name)s : %(message)s",'%Y%m%d %H:%M:%S')
#~ h.setLevel(logging.INFO)
#~ h.setFormatter(fileformat)
#~ myappl.log.error_log.addHandler(h)
# MakeRotatingFileHandler for the access log.
#~ h = logging.handlers.TimedRotatingFileHandler(os.path.normpath(os.path.join(botsglobal.ini.get('directories','botspath'), 'botssys/logging/webserver.log')),when='midnight', backupCount=10)
#~ h.setLevel(logging.DEBUG)
#~ myappl.log.access_log.addHandler(h)
#~ botsglobal.logger = myappl.log.access_log
#write start info to cherrypy log********************************************
botsglobal.logger.info(_(u'Bots web server started.'))
botsglobal.logger.info(_(u'Python version: "%s".'),sys.version)
botsglobal.logger.info(_(u'Django version: "%s".'),django.VERSION)
#start cherrypy *********************************************************************
cherrypy.engine.start()
cherrypy.engine.block()
def __init__(self):
WSGIHandler.__init__(self)
import settings as cust_settings
settings.configure(cust_settings)
def run(self, parameters):
#cherrypy.engine.unsubscribe('graceful', cherrypy.log.reopen_files)
logging.config.dictConfig(OmniDB.settings.LOGGING)
#cherrypy.log.error_log.propagate = False
cherrypy.log.access_log.propagate = False
self.mount_static(OmniDB.settings.STATIC_URL,
OmniDB.settings.STATIC_ROOT)
cherrypy.tree.graft(WSGIHandler())
port = parameters['listening_port']
num_attempts = 0
print('''Starting OmniDB server...''', flush=True)
logger.info('''Starting OmniDB server...''')
print('''Checking port availability...''', flush=True)
logger.info('''Checking port availability...''')
while not check_port(port) or num_attempts >= 20:
print("Port {0} is busy, trying another port...".format(port),
flush=True)
logger.info(
"Port {0} is busy, trying another port...".format(port))
port = random.randint(1025, 32676)
num_attempts = num_attempts + 1
if num_attempts < 20:
v_cherrypy_config = {
'server.socket_host': parameters['listening_address'],
'server.socket_port': port,
'engine.autoreload_on': False,
'log.screen': False,
'log.access_file': '',
'log.error_file': ''
}
if parameters['is_ssl']:
import ssl
ssl_ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
ssl_ctx.options |= ssl.OP_NO_TLSv1
ssl_ctx.options |= ssl.OP_NO_TLSv1_1
ssl_ctx.load_cert_chain(parameters['ssl_certificate_file'],
parameters['ssl_key_file'])
v_cherrypy_config['server.ssl_module'] = 'builtin'
v_cherrypy_config['server.ssl_certificate'] = parameters[
'ssl_certificate_file']
v_cherrypy_config['server.ssl_private_key'] = parameters[
'ssl_key_file']
v_cherrypy_config['server.ssl_context'] = ssl_ctx
cherrypy.config.update(v_cherrypy_config)
print("Starting server {0} at {1}:{2}{3}.".format(
OmniDB.settings.OMNIDB_VERSION,
parameters['listening_address'], str(port),
OmniDB.settings.PATH),
flush=True)
logger.info("Starting server {0} at {1}:{2}.".format(
OmniDB.settings.OMNIDB_VERSION,
parameters['listening_address'], str(port)))
# Startup
startup.startup_procedure()
cherrypy.engine.start()
if not app_version:
print("Open OmniDB in your favorite browser", flush=True)
if platform.system() != 'Windows':
print("Press Ctrl+C to exit", flush=True)
else:
#Sending response to electron app
print(
"http://localhost:{0}/login/?user=admin&pwd=admin&token={1}"
.format(str(port), OmniDB.custom_settings.APP_TOKEN),
flush=True)
cherrypy.engine.block()
cherrypy.engine.exit()
else:
print('Tried 20 different ports without success, closing...',
flush=True)
logger.info('Tried 20 different ports without success, closing...')
def benchmark_request(middleware_classes):
settings.MIDDLEWARE_CLASSES = middleware_classes
req_factory = RequestFactory()
handler = WSGIHandler()
handler.load_middleware()
handler.get_response(req_factory.get('/'))
import os
from wsgiref.simple_server import make_server
from django.core.handlers.wsgi import WSGIHandler
from django.core.servers.basehttp import AdminMediaHandler
os.environ['DJANGO_SETTINGS_MODULE'] = 'settings'
httpd = make_server('', 8000, AdminMediaHandler(WSGIHandler()))
httpd.serve_forever()
