diff --git a/console/tunnel.py b/console/tunnel.py new file mode 100644 index 0000000..a6ba2c8 --- /dev/null +++ b/console/tunnel.py @@ -0,0 +1,145 @@ +# -*- coding: utf-8 -*- +# +# This class provide from VirtManager project, from console.py +# file. +# +# Copyright (C) 2006-2008 Red Hat, Inc. +# Copyright (C) 2006 Daniel P. Berrange +# Copyright (C) 2010 Marc-André Lureau +# +# 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 2 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, write to the Free Software +# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, +# MA 02110-1301 USA. +# + +import os +import socket +import signal +import logging + + +class Tunnel(object): + def __init__(self): + self.outfd = None + self.errfd = None + self.pid = None + + def open(self, connhost, connuser, connport, gaddr, gport, gsocket): + if self.outfd is not None: + return -1 + + # Build SSH cmd + argv = ["ssh", "ssh"] + if connport: + argv += ["-p", str(connport)] + + if connuser: + argv += ['-l', connuser] + + argv += [connhost] + + # Build 'nc' command run on the remote host + # + # This ugly thing is a shell script to detect availability of + # the -q option for 'nc': debian and suse based distros need this + # flag to ensure the remote nc will exit on EOF, so it will go away + # when we close the VNC tunnel. If it doesn't go away, subsequent + # VNC connection attempts will hang. + # + # Fedora's 'nc' doesn't have this option, and apparently defaults + # to the desired behavior. + # + if gsocket: + nc_params = "-U %s" % gsocket + else: + nc_params = "%s %s" % (gaddr, gport) + + nc_cmd = ( + """nc -q 2>&1 | grep "requires an argument" >/dev/null;""" + """if [ $? -eq 0 ] ; then""" + """ CMD="nc -q 0 %(nc_params)s";""" + """else""" + """ CMD="nc %(nc_params)s";""" + """fi;""" + """eval "$CMD";""" % + {'nc_params': nc_params}) + + argv.append("sh -c") + argv.append("'%s'" % nc_cmd) + + argv_str = reduce(lambda x, y: x + " " + y, argv[1:]) + logging.debug("Creating SSH tunnel: %s", argv_str) + + fds = socket.socketpair() + errorfds = socket.socketpair() + + pid = os.fork() + if pid == 0: + fds[0].close() + errorfds[0].close() + + os.close(0) + os.close(1) + os.close(2) + os.dup(fds[1].fileno()) + os.dup(fds[1].fileno()) + os.dup(errorfds[1].fileno()) + os.execlp(*argv) + os._exit(1) + else: + fds[1].close() + errorfds[1].close() + + logging.debug("Tunnel PID=%d OUTFD=%d ERRFD=%d", + pid, fds[0].fileno(), errorfds[0].fileno()) + errorfds[0].setblocking(0) + + self.outfd = fds[0] + self.errfd = errorfds[0] + self.pid = pid + + fd = fds[0].fileno() + if fd < 0: + raise SystemError("can't open a new tunnel: fd=%d" % fd) + return fd + + def close(self): + if self.outfd is None: + return + + logging.debug("Shutting down tunnel PID=%d OUTFD=%d ERRFD=%d", + self.pid, self.outfd.fileno(), + self.errfd.fileno()) + self.outfd.close() + self.outfd = None + self.errfd.close() + self.errfd = None + + os.kill(self.pid, signal.SIGKILL) + self.pid = None + + def get_err_output(self): + errout = "" + while True: + try: + new = self.errfd.recv(1024) + except: + break + + if not new: + break + + errout += new + + return errout diff --git a/webvirtcloud/gunicorn.conf.py b/webvirtcloud/gunicorn.conf.py new file mode 100644 index 0000000..46a921a --- /dev/null +++ b/webvirtcloud/gunicorn.conf.py @@ -0,0 +1,210 @@ +import os + +# Sample Gunicorn configuration file. + +# +# Server socket +# +# bind - The socket to bind. +# +# A string of the form: 'HOST', 'HOST:PORT', 'unix:PATH'. +# An IP is a valid HOST. +# +# backlog - The number of pending connections. This refers +# to the number of clients that can be waiting to be +# served. Exceeding this number results in the client +# getting an error when attempting to connect. It should +# only affect servers under significant load. +# +# Must be a positive integer. Generally set in the 64-2048 +# range. +# + +bind = '127.0.0.1:8000' +backlog = 2048 + +# +# Worker processes +# +# workers - The number of worker processes that this server +# should keep alive for handling requests. +# +# A positive integer generally in the 2-4 x $(NUM_CORES) +# range. You'll want to vary this a bit to find the best +# for your particular application's work load. +# +# worker_class - The type of workers to use. The default +# async class should handle most 'normal' types of work +# loads. You'll want to read http://gunicorn/deployment.hml +# for information on when you might want to choose one +# of the other worker classes. +# +# An string referring to a 'gunicorn.workers' entry point +# or a python path to a subclass of +# gunicorn.workers.base.Worker. The default provided values +# are: +# +# egg:gunicorn#sync +# egg:gunicorn#eventlet - Requires eventlet >= 0.9.7 +# egg:gunicorn#gevent - Requires gevent >= 0.12.2 (?) +# egg:gunicorn#tornado - Requires tornado >= 0.2 +# +# worker_connections - For the eventlet and gevent worker classes +# this limits the maximum number of simultaneous clients that +# a single process can handle. +# +# A positive integer generally set to around 1000. +# +# timeout - If a worker does not notify the master process in this +# number of seconds it is killed and a new worker is spawned +# to replace it. +# +# Generally set to thirty seconds. Only set this noticeably +# higher if you're sure of the repercussions for sync workers. +# For the non sync workers it just means that the worker +# process is still communicating and is not tied to the length +# of time required to handle a single request. +# +# keepalive - The number of seconds to wait for the next request +# on a Keep-Alive HTTP connection. +# +# A positive integer. Generally set in the 1-5 seconds range. +# + + +def get_workers(): + procs = os.sysconf('SC_NPROCESSORS_ONLN') + if procs > 0: + return procs * 2 + 1 + else: + return 3 + + +workers = get_workers() +# worker_class = 'egg:gunicorn#eventlet' +worker_connections = 1000 +timeout = 600 +keepalive = 2 + +# +# Debugging +# +# debug - Turn on debugging in the server. This limits the number of +# worker processes to 1 and changes some error handling that's +# sent to clients. +# +# True or False +# +# spew - Install a trace function that spews every line of Python +# that is executed when running the server. This is the +# nuclear option. +# +# True or False +# + +debug = False +spew = False + +# +# Server mechanics +# +# daemon - Detach the main Gunicorn process from the controlling +# terminal with a standard fork/fork sequence. +# +# True or False +# +# pidfile - The path to a pid file to write +# +# A path string or None to not write a pid file. +# +# user - Switch worker processes to run as this user. +# +# A valid user id (as an integer) or the name of a user that +# can be retrieved with a call to pwd.getpwnam(value) or None +# to not change the worker process user. +# +# group - Switch worker process to run as this group. +# +# A valid group id (as an integer) or the name of a user that +# can be retrieved with a call to pwd.getgrnam(value) or None +# to change the worker processes group. +# +# umask - A mask for file permissions written by Gunicorn. Note that +# this affects unix socket permissions. +# +# A valid value for the os.umask(mode) call or a string +# compatible with int(value, 0) (0 means Python guesses +# the base, so values like "0", "0xFF", "0022" are valid +# for decimal, hex, and octal representations) +# +# tmp_upload_dir - A directory to store temporary request data when +# requests are read. This will most likely be disappearing soon. +# +# A path to a directory where the process owner can write. Or +# None to signal that Python should choose one on its own. +# + +daemon = False +pidfile = None +umask = 0 +user = None +group = None +tmp_upload_dir = None + +# +# Logging +# +# logfile - The path to a log file to write to. +# +# A path string. "-" means log to stdout. +# +# loglevel - The granularity of log output +# +# A string of "debug", "info", "warning", "error", "critical" +# + +logfile = '-' +loglevel = 'info' +accesslog = '-' + +# +# Process naming +# +# proc_name - A base to use with setproctitle to change the way +# that Gunicorn processes are reported in the system process +# table. This affects things like 'ps' and 'top'. If you're +# going to be running more than one instance of Gunicorn you'll +# probably want to set a name to tell them apart. This requires +# that you install the setproctitle module. +# +# A string or None to choose a default of something like 'gunicorn'. +# + +proc_name = None + +# +# Server hooks +# +# post_fork - Called just after a worker has been forked. +# +# A callable that takes a server and worker instance +# as arguments. +# +# pre_fork - Called just prior to forking the worker subprocess. +# +# A callable that accepts the same arguments as after_fork +# +# pre_exec - Called just prior to forking off a secondary +# master process during things like config reloading. +# +# A callable that takes a server instance as the sole argument. +# +# +# def post_fork(server, worker): +# pass +# +# def pre_fork(server, worker): +# pass +# +# def pre_exec(server): +# pass