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