def execute_log_start(self, cmd, wrap_cmd):
# store ssh command
fp_ssh_raw = open(
glob.getfile(glob.config.get("logging", "ssh_raw")), "a"
)
fp_ssh_raw.write("\n\n\n\n%s%s%s" % (wrap_cmd[1], cmd, wrap_cmd[2]))
fp_ssh_raw.close()
def event_log(self, cls, cmd, control, error_code):
# entity has a driver
try:
control.entity.driver
# read driver config for messages
q_messages.read_driver(control.entity.driver)
# add drivers path to system path for import
sys.path.append(glob.getfile("drivers", control.entity.driver))
# import, and make sure it exists
try:
exec("from %s_q_after_exec import %s_q_after_exec" % (
control.entity.driver, control.entity.driver
))
exec("tmp = %s_q_after_exec()" % control.entity.driver)
exec("after_ret = tmp.execute(cls, cmd, control.entity)")
except ImportError:
after_ret = errors.throw(DRIVER_NO_AFTER_EXEC)
# entity has no driver
except AttributeError:
# queue_mode afterwards execution
from q_after_exec import q_after_exec
tmp = q_after_exec()
after_ret = tmp.execute(cmd, cls, control.entity)
# get event message
event_msg = q_messages.get(cls, cmd, control.entity, error_code)
# insert event if there is a message
if event_msg != None:
php.db_update("events", "insert", event_msg, error_code[0])
def db_update(*args):
return execute("%s %s \"%s\"" % (
glob.config.get("paths", "php"),
glob.getfile("shared/bridge", "db_update.php"),
"\" \"".join(args)
)
)
def __init__(self, dict):
super(vps, self).__init__(dict)
# verify all fields are present
if not self.require([
"vps_id",
"hostname",
"driver",
"server",
"master"
]):
return errors.throw(errors.BACKEND_INVALID_INPUT)
# force casting of vps fields
self.force_cast_int("vps_id")
# verify all master fields are present
if not self.require_dict(self.master, [
"server_id",
"parent_server_id",
"hostname",
"ip",
"port"
]):
return errors.throw(errors.BACKEND_INVALID_INPUT)
# force casting of master fields
self.force_cast_int_dict("master", [
"server_id",
"parent_server_id",
"port"
])
# verify all server fields are present
if not self.require_dict(self.server, [
"server_id",
"parent_server_id",
"hostname",
"ip",
"port"
]):
return errors.throw(errors.BACKEND_INVALID_INPUT)
# force casting of server fields
self.force_cast_int_dict("server", [
"server_id",
"parent_server_id",
"port"
])
# add drivers path to system path for import
sys.path.append(glob.getfile("drivers", self.driver))
# start out with undefined executer
self.executer = None
def execute_log_end(self,
cmd, wrap_cmd, wrap_output, exit_code, stdout, stderr
):
# store stdout
out_stdout=stdout[:]
out_stdout.insert(0, wrap_output[0])
out_stdout.append(wrap_output[1])
fp_action = open(
glob.getfile(glob.config.get("logging", "action")), "a"
)
fp_action.write("\n".join(out_stdout)+"\n")
fp_action.close()
# store stderr, if necessary
if exit_code != 0 or stderr != []:
out_stderr=stderr[:]
out_stderr.insert(0, wrap_output[0])
out_stderr.append(wrap_output[1])
fp_stderr = open(
glob.getfile(glob.config.get("errors", "file_error")), "a"
)
fp_stderr.write("\n".join(out_stderr)+"\n")
fp_stderr.close()
def initialize_bw_cron(self):
# delete cron (sanity)
self.uinitialize_bw_cron()
# add cronjob
self.do_execute(
'echo "\n# panenthe_bw\n17 3 * * * root '
+ glob.getfile("shared/drivers/backend.py")
+ " "
+ 'masterctl cron_daily -d \\"%s\\" # panenthe_bw" >> %s'
% (str(self.get_dict()), glob.config.get("paths", "crontab"))
)
return errors.throw(errors.ERR_SUCCESS)
def throw(error):
# don't log successes
success_codes = glob.config.get("main", "success_codes").split("|")
if len(success_codes) > 1:
for code in success_codes:
code = code.strip()
if error[2] == code:
return error
# get time
import time
time = time.strftime(glob.config.get("errors", "date_format"))
# write to system log
sys_error = open(
glob.getfile(glob.config.get("errors", "file_sys_error")), "a"
)
sys_error.write("%s:PY:%s:%s\n" % (time, error[0], error[1]))
sys_error.close()
return error
def execute(self):
# note: no super()
# add drivers path to system path for import
sys.path.append(glob.getfile("drivers", self.driver))
# import, and make sure it exists
try:
exec("import %s_core" % self.driver)
except ImportError:
return errors.throw(errors.DRIVER_NOT_FOUND)
# check to make sure the method is supported
try:
exec("%s_core.%s_core.%s" % (self.driver, self.driver, self.cmd))
except AttributeError:
return errors.throw(errors.DRIVER_METHOD_NOT_SUPPORTED)
# execute method
exec("self.entity = %s_core.%s_core(self.dict)" % \
(self.driver, self.driver))
return eval("self.entity.%s()" % self.cmd)
args = sys.argv.pop(1)
# create queue object
queue = q()
# push initial command onto queue
queue.push(id, [], cls, cmd, args)
# child daemonizes and executes until it's out of things to run
if os.fork() == 0:
# get pid
pid = os.getpid()
# make fifo
fifo_name = glob.getfile("srv/tmp", "panenthe_q.%s" % pid)
os.mkfifo(fifo_name)
# redirect stdout and stderr to files
sys.stdout = open(glob.getfile("logs/panq_stdout"), "a")
sys.stderr = open(glob.getfile("logs/panq_stderr"), "a")
# output that a new process has started
sys.stdout.write("\n\n\n--\n\n\nnew queue pid: %d\n\n" % pid)
sys.stdout.flush()
# catch uncaught exceptions
try:
# start daemon
queue.daemon(fifo_name)
except Exception, e:
def create(self):
ret = super(ovz_core, self).create()
if ret: return ret
# copy OS template if necessary
if self.server_is_slave():
# sanitize OST path
self.do_execute("mkdir -p %s" %
glob.config.get("paths", "ost_ovz")
)
# get OST path
ost_path = os.path.join(
glob.config.get("paths", "ost_ovz"),
executer.escape(self.ost)
)
# sync OST file
server = self.get_server()
server.file_sync(ost_path)
# OST directory exists
(exit_code,_,_) = self.do_execute(
"test -e /vz/template/cache"
)
# exists, get rid of it
if exit_code == 0:
# check for OST directory symlink
(exit_code,_,_) = self.do_execute(
"test -L /vz/template/cache"
)
# is a symlink, remove it
if exit_code == 0:
self.do_execute("rm -f /vz/template/cache")
# not a symlink? fix it
else:
# check if destination exists
(exit_code,_,_) = self.do_execute(
"test -e /vz/template/__cache"
)
# if it does, remove it
if exit_code == 0:
self.do_execute("rm -rf /vz/template/__cache")
# move to new directory
self.do_execute(
"mv /vz/template/cache /vz/template/__cache"
)
# make symlink
self.do_execute(
"ln -s %s /vz/template/cache" %
glob.config.get("paths", "ost_ovz")
)
# get ost name
ost_name = self.get_ost_name()
# delete default config
self.do_execute(
"rm -f %s" % glob.config.get("paths", "vzconf_default")
)
# copy default config over
execute(
"scp -i %s -P %d %s root@%s:%s" % (
glob.config.get("paths", "master_private_key"),
self.server['port'],
glob.getfile("shared/etc/ovz_vm_default.conf"),
executer.escape(self.server['ip']),
glob.config.get("paths", "vzconf_default")
)
)
"""
# check if disk quotas are enabled
(exit_code,stdout,_) = self.do_execute(
"/usr/bin/env grep DISK_QUOTA %s" %
glob.config.get("paths", "vzconf")
)
# disk quotas not set
if exit_code != 0:
disk_quotas = None
else:
# disk quotas not set
stdout_str = "\n".join(stdout).strip()
if stdout_str == "":
disk_quotas = None
# disk quotas set to yes
elif stdout_str.lower().find("yes"):
disk_quotas = True
# disk quotas set to no
else:
disk_quotas = False
# disable disk quotas for create if enabled
if disk_quotas == True:
self.do_execute(
"/usr/bin/env sed -r " +
"\"s/^[ ]*DISK_QUOTA[ ]*=.*$/DISK_QUOTA=no/g\" -i %s" %
glob.config.get("paths", "vzconf")
)
# make sure disk quotas are disabled if set as default
elif disk_quotas == None:
self.do_execute("echo \"DISK_QUOTA=no\" >> %s" %
glob.config.get("paths", "vzconf")
)
# else: it's already disabled...
"""
# remove directory if it's empty; goes with get_new_real_id()
(exit_code,_,_) = self.do_execute("rmdir /vz/private/%d" % self.real_id)
# create
(exit_code,_,_) = self.do_execute( # prolog anyone?
"%s create %d --ostemplate %s --hostname %s" % (
glob.config.get("paths", "vzctl"),
self.real_id,
executer.escape(ost_name),
executer.escape(self.hostname)
)
)
"""
# re-enable disk quotas if necessary
if disk_quotas == True:
self.do_execute(
"/usr/bin/env sed -r " +
"\"s/^[ ]*DISK_QUOTA[ ]*=.*$/DISK_QUOTA=yes/g\" -i %s" %
glob.config.get("paths", "vzconf")
)
# delete line if it wasn't there before
elif disk_quotas == None:
self.do_execute("/usr/bin/env sed \"/DISK_QUOTA/d\" -i %s" %
glob.config.get("paths", "vzconf")
)
"""
# fail
if exit_code != 0:
return ovz_exit_codes.translate(exit_code)
# continue setting stuff
(exit_code,_,_) = self.do_execute(
"%s set %d --save --setmod restart --quotaugidlimit 3000 " % (
glob.config.get("paths", "vzctl"),
self.real_id
) + \
"--cpulimit %d --cpus %d " % (
self.cpu_pct,
self.cpu_num
) + \
# http://www.linux.com/archive/feature/114214
"--vmguarpages %d --privvmpages %d --diskspace %dK" % (
(self.g_mem*256/1024), (self.b_mem*256/1024), self.disk_space
)
)
return ovz_exit_codes.translate(exit_code)
def __init__(self, call_name, params):
self.cmd_params = ""
for key, value in params.iteritems():
self.cmd_params += " --%s %s" % (key, value)
self.call_path = glob.getfile("ui/api", call_name + ".php")
def read_driver(driver):
messages.read(
glob.getfile("drivers", driver, "%s_q_messages.conf" % driver)
)
#!/usr/bin/env python
# Panenthe: q_messages.py
# Loads and compiles queue event messages.
import glob
import errors
##
import ConfigParser
import os
# read messages from config
messages = ConfigParser.SafeConfigParser()
messages.read(glob.getfile("shared/etc/q_messages.conf"))
# read the driver's messages to overwrite
def read_driver(driver):
messages.read(
glob.getfile("drivers", driver, "%s_q_messages.conf" % driver)
)
# get queue message
def get(cls, cmd, entity, code):
# get section
if code == errors.ERR_SUCCESS:
section = "success"
else:
section = "fail"
# queue mode
if queue_mode:
# look for panenthe_q.py running
q = os.popen("/usr/bin/env ps -o pid,command -C python", "r")
ps_lines = q.readlines()
# generate id
id = backend.generate_randstr()
is_running = False
for line in ps_lines:
if line.find("panenthe_q.py") != -1:
pid = int(line.strip().split(" ")[0])
fifo_path = glob.getfile("srv/tmp", "panenthe_q.%s" % pid)
# check fifo to see if it exists
try:
os.stat(fifo_path)
# fifo exists, yay!
is_running = True
break
# no fifo... kill the process because it's rogue... like
# Jack Bauer. This only applies to panenthe_q.py processes, so
# be careful.
except OSError:
os.kill(pid, signal.SIGTERM)
if is_running:
# Panenthe: errors.py
# Loads errors and provides an interface for throwing them.
##
import glob
# error severities
SEVERITY_NORMAL = "NORMAL"
SEVERITY_NOTICE = "NOTICE"
SEVERITY_WARNING = "WARNING"
SEVERITY_FATAL = "FATAL"
# get error codes
error_file = open(glob.getfile("shared/etc/errors"), "r")
error_lines = error_file.readlines()
error_file.close()
# loop lines and define all errors
for line in error_lines:
# deal with comments
if line[0]=="#": continue
error_split = line.split("|")
if len(error_split) > 1:
error_code = error_split[0].strip()
error_severity = error_split[2].strip()
error_name = error_split[2].strip()
exec("%s = (\"%s\", \"%s\", \"%s\")" % (
error_name, error_code, error_severity, error_name
