def __update_control_list(self, datastore, vmname, pdu, port):
has_datastore = False
for node_list in self.__nodes_control_list:
if node_list.has_key(datastore):
node_found = False
for node_info in node_list[datastore]:
if node_info['node_name'] == vmname:
node_info['control_pdu'] = pdu
node_info['control_port'] = port
node_found = True
if node_found is False:
node_info = {}
node_info['node_name'] = vmname
node_info['control_pdu'] = pdu
node_info['control_port'] = port
node_list[datastore].append(node_info)
has_datastore = True
if has_datastore is False:
vm_list = {}
vm_list[datastore] = []
ni = {}
ni['node_name'] = vmname
ni['control_pdu'] = pdu
ni['control_port'] = port
vm_list[datastore].append(ni)
self.__nodes_control_list.append(vm_list)
logger.info("Updated. nodes control list: {0}".
format(self.__nodes_control_list))
def main_loop(self):
rlist = []
rlist.append(self.__pipe.inform)
timeout = 10
print "Total threads: {0}".format(threading.activeCount())
try:
while self.__running:
readable, _, _ = select.select(rlist, [], [], timeout)
if not readable:
continue
if self.__pipe.inform in readable:
try:
message = self.__pipe.read(256)
except OSError, exc:
logger.warn("[Error %d] appeared at reading pipe" %
exc.errno)
continue
if len(message) == 0:
continue
pdu_id = message.split()[0].split('.')[-2]
pdu_index = self.to_index(int(pdu_id))
logger.info("Assign message to pdu {0}".format(pdu_id))
self.__pdus[pdu_index].handle_message(message)
except KeyboardInterrupt:
logger.error("Break by user.")
except Exception, ex:
logger.error("{0}: {1}".format(sys._getframe().f_code.co_name, ex))
def send_command(self, cmd):
logger.info("Executing command: {0}".format(cmd))
if self.transport is None or self.transport.is_active() is False:
self.reconnect()
if self.transport is None or self.transport.is_active() is False:
logger.error("Connection not established failed.")
return -1, None
try:
session = self.transport.open_session()
session.set_combine_stderr(True)
session.get_pty()
session.invoke_shell()
if session.send_ready():
index = 0
input_data = self.__fix_indata(cmd)
if index < len(input_data):
data = input_data[index] + '\n'
index += 1
session.send(data)
else:
logger.warn("session is not ready for send")
except paramiko.SSHException as ex:
logger.error("Exception for command '{0}: {1}'".format(cmd, ex))
session.close()
return -1, None
output = self.poll(session)
status = session.recv_exit_status()
# send quit to notify server shutdown the channel
session.send("quit\n")
logger.info("Returned status {0}".format(status))
session.close()
return status, output
def send_command(self, cmd):
logger.info("Executing command: {0}".format(cmd))
if self.transport is None or self.transport.is_active() is False:
self.reconnect()
if self.transport is None or self.transport.is_active() is False:
logger.error("Connection not established failed.")
return -1, None
try:
session = self.transport.open_session()
session.set_combine_stderr(True)
session.get_pty()
session.invoke_shell()
if session.send_ready():
index = 0
input_data = self.__fix_indata(cmd)
if index < len(input_data):
data = input_data[index] + '\n'
index += 1
session.send(data)
else:
logger.warn("session is not ready for send")
except paramiko.SSHException as ex:
logger.error("Exception for command '{0}: {1}'".format(cmd, ex))
session.close()
return -1, None
output = self.poll(session)
status = session.recv_exit_status()
# send quit to notify server shutdown the channel
session.send("quit\n")
logger.info("Returned status {0}".format(status))
session.close()
return status, output
def update_snmprec_file(self, oid, val):
old_file = os.path.join(self.config_instance.snmp_data_dir,
"public.snmprec")
new_file = os.path.join(self.config_instance.snmp_data_dir,
"new.snmprec")
logger.info("update oid %s, val %s" % (oid, str(val)))
# open file
try:
old_fdh = open(old_file, 'r')
new_fdh = open(new_file, 'w')
while True:
line = old_fdh.readline()
if not line:
break
record_list = line.strip(os.linesep).split('|')
if record_list[0] == oid:
record_list[2] = val
new_line = '|'.join(["%s" % x for x in record_list])
new_fdh.write(new_line + os.linesep)
else:
new_fdh.write(line)
except IOError as e:
logger.error(
"Exception in updating snmprec file, exception: {}".format(e))
return
new_fdh.close()
old_fdh.close()
os.rename(new_file, old_file)
def update_snmprec_file(self, oid, val):
old_file = os.path.join(self.config_instance.snmp_data_dir,
"public.snmprec")
new_file = os.path.join(self.config_instance.snmp_data_dir,
"new.snmprec")
logger.info("update oid %s, val %s" % (oid, str(val)))
# open file
try:
old_fdh = open(old_file, 'r')
new_fdh = open(new_file, 'w')
while True:
line = old_fdh.readline()
if not line:
break
record_list = line.strip(os.linesep).split('|')
if record_list[0] == oid:
record_list[2] = val
new_line = '|'.join(["%s" % x for x in record_list])
new_fdh.write(new_line + os.linesep)
else:
new_fdh.write(line)
except IOError as e:
logger.error("Exception in updating snmprec file, exception: {}".
format(e))
return
new_fdh.close()
old_fdh.close()
os.rename(new_file, old_file)
def __execute_command(self, cmd):
'''
Excute command
'''
if self.__ssh.connected() is False:
logger.info("Connection is not connected")
return self.__ssh.exec_command(cmd)
def __execute_command(self, cmd):
'''
Excute command
'''
if self.__ssh.connected() is False:
logger.info("Connection is not connected")
return self.__ssh.exec_command(cmd)
def connect(self, timeout=30):
logger.info("Connecting {username}@{host}:{port}".format(
username=self.host_username,
host=self.host_ip,
port=self.host_port))
self.ssh = paramiko.SSHClient()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
return self.reconnect(timeout)
def signal_handler(signum, frame):
logger.info("Signal {0} receivced.".format(signum))
if vpdu_handler:
vpdu_handler.stop()
if sim_serv:
sim_serv.stop()
logger.info("vPDU exit.")
sys.exit(0)
def handle_outlet(self, args):
'''
1. Get current outlet state
2. Get the current outlet action
'''
# self.logger.info("handle outlet {0}/{1}".format(outlet, self.pdu))
outlet = args[0]
action = args[1]
logger.info("handle outlet {0}/{1}, action: {2}"
.format(outlet, self.pdu, self.actions[int(action)]))
vmname = self.__node_control_handler.get_node_name(1, int(outlet))
if vmname is None:
self.set_outlet_field(self.outlet_action_oid_offset, outlet, 0)
logger.error("No virtual node found for outlet {0}".format(outlet))
return
datastore = self.__node_control_handler.get_node_datastore(vmname)
if datastore is None:
self.set_outlet_field(self.outlet_action_oid_offset, outlet, 0)
logger.error("No datastore found for virtual node {0}"
.format(vmname))
return
# action = self.get_outlet_field(self.outlet_action_oid_offset, outlet)
state = self.get_outlet_field(self.outlet_state_oid_offset, outlet)
if self.actions[int(action)] == 'none' or \
self.actions[int(action)] == self.states[int(state)]:
logger.warn("No need to execute the action: {}"
.format(self.actions[int(action)]))
return
# restore the action default to "none"
if self.actions[int(action)] == 'on':
# 'on' state
self.set_outlet_field(self.outlet_state_oid_offset, outlet, 5)
status = self.__node_control_handler.power_on_node(datastore,
vmname)
elif self.actions[int(action)] == 'off':
# 'off' state
self.set_outlet_field(self.outlet_state_oid_offset, outlet, 4)
status = self.__node_control_handler.power_off_node(datastore,
vmname)
elif self.actions[int(action)] == 'reboot':
# 'off' state
self.set_outlet_field(self.outlet_state_oid_offset, outlet, 8)
status = self.__node_control_handler.reboot_node(datastore, vmname)
# 'on' state
self.set_outlet_field(self.outlet_state_oid_offset, outlet, 5)
else:
logger.error("Unknown action: {0}".format(action))
return
if status != 0:
logger.error("Failed to {0} virtual node."
.format(self.actions[int(action)]))
return
self.set_outlet_field(self.outlet_action_oid_offset, outlet, 0)
def connect(self, timeout=30):
logger.info("Connecting {username}@{host}:{port}"
.format(username=self.host_username,
host=self.host_ip,
port=self.host_port))
self.ssh = paramiko.SSHClient()
self.ssh.set_missing_host_key_policy(paramiko.AutoAddPolicy())
return self.reconnect(timeout)
def stop(self):
# kill the service if already run
pid = self.getpid()
if pid < 0:
logger.info("snmpsim service is not running.")
return
os.kill(pid, signal.SIGTERM)
logger.info("Snmpsim service [%d] exit." % pid)
def signal_handler(signum, frame):
logger.info("Signal {0} receivced.".format(signum))
if vpdu_handler:
vpdu_handler.stop()
if sim_serv:
sim_serv.stop()
logger.info("vPDU exit.")
sys.exit(0)
def handle_message(self, message):
logger.info("Got new message {0}".format(message))
oid = message.split()[0]
outlet = oid.split('.')[-1]
value = message.split()[1]
if oid.startswith(self.outlet_action_oid_offset):
self.add_task("handle outlet {0}".format(outlet),
self.handle_outlet, int(outlet), value)
else:
logger.warn("{0} is not handled now.".format(message))
def signal_handler(signum, frame):
vpdu_pid = get_vpdu_pid()
if vpdu_pid > 0:
os.kill(vpdu_pid, signal.SIGTERM)
snmpsim_pid = SNMPSimService.getpid()
if snmpsim_pid > 0:
os.kill(snmpsim_pid, signal.SIGTERM)
logger.info("Exit server.")
sys.exit(0)
def add_task(self, task_name, func, *args):
'''
tasks: (fun, args)
'''
task_name = "{task_name}-ID-{task_id}".\
format(task_name=task_name, task_id=self.__task_id)
self.__task_id += 1
logger.info("Add task: {yellow}{task_name}{normal} for pdu {pdu}".
format(yellow=colors.YELLOW, task_name=task_name,
normal=colors.NORMAL, pdu=self.pdu))
self.__tasks_queue.put((task_name, func, args))
def handle_message(self, message):
oid = message.split()[0]
outlet = oid.split('.')[-1]
value = message.split()[1]
logger.info("Handle message {0}".format(message))
if message.startswith(self.pduouton_oid_offset):
self.add_task("handle_outlet-{0}".format(outlet),
self.handle_outlet, int(outlet), value)
elif message.startswith(self.pduoutpwd_oid_offset):
self.add_task("handle_password-{0}".format(outlet),
self.handle_password, int(outlet), value)
else:
logger.warn("{0} is not handled now.".format(message))
def handle_outlet(self, args):
outlet = args[0]
action = args[1]
logger.info("handle outlet {0}/{1}, action: {2}".
format(outlet, self.pdu, self.actions[int(action)]))
on_offset = self.pduouton_oid_offset + "." + str(self.to_pdu(self.pdu))
action_in_oid = self.extract(self.get_outlet_field(on_offset, outlet))
logger.warn("action: {0}, action_in_oid: {1}".
format(self.actions[int(action)],
self.actions[int(action_in_oid)]))
vmname = self.__node_control_handler.get_node_name(int(self.pdu),
int(outlet))
if vmname is None:
logger.error("No virtual node found for outlet {0}".format(outlet))
return
datastore = self.__node_control_handler.get_node_datastore(vmname)
if datastore is None:
logger.error("No datastore found for virtual node {0}".
format(vmname))
return
# Make sure the action as the last one
logger.info("last action: {0}, current action: {1}".
format(self.action_list[int(outlet) - 1],
self.actions[int(action)]))
if self.action_list[int(outlet) - 1] == self.actions[int(action)]:
logger.warn("No need to execute action for {0}/{1}".
format(outlet, self.pdu))
return
if self.actions[int(action)] == 'on':
status = self.__node_control_handler.power_on_node(datastore,
vmname)
elif self.actions[int(action)] == 'off':
status = self.__node_control_handler.power_off_node(datastore,
vmname)
elif self.actions[int(action)] == 'reboot':
status = self.__node_control_handler.reboot(datastore, vmname)
else:
logger.error("Unknown action: {0}".format(action))
if status != 0:
logger.error("Failed to {0} virtual node.".
format(self.actions[int(action)]))
return
self.action_list[int(outlet) - 1] = self.actions[int(action)]
def start_vpdu():
vpdu_command = "vpdud.py"
if not os.path.exists("/usr/bin/vpdud.py") or \
not os.path.exists("/usr/local/bin"):
vpdu_command = os.path.join(os.path.dirname(os.path.abspath(__file__)),
"vpdud.py")
command = vpdu_command + " " + \
"-d --logging-method=file:/var/log/vpdud/vpdud.log"
logger.info(command)
retcode = subprocess.call(command, shell=True)
# wait service started
time.sleep(10)
return retcode
def reboot_node(self, *args):
'''
Reboot VM
'''
datastore = args[0]
vmname = args[1]
logger.info("Reboot " + datastore + "/" + vmname + "...")
status = self.power_off_node(datastore, vmname)
if status != 0:
return status
# sleep 2 seconds
time.sleep(2)
status = self.power_on_node(datastore, vmname)
return status
def reboot_node(self, *args):
'''
Reboot VM
'''
datastore = args[0]
vmname = args[1]
logger.info("Reboot " + datastore + "/" + vmname + "...")
status = self.power_off_node(datastore, vmname)
if status != 0:
return status
# sleep 2 seconds
time.sleep(2)
status = self.power_on_node(datastore, vmname)
return status
def add_task(self, task_name, func, *args):
'''
tasks: (fun, args)
'''
task_name = "{task_name}-ID-{task_id}".\
format(task_name=task_name, task_id=self.__task_id)
self.__task_id += 1
logger.info(
"Add task: {yellow}{task_name}{normal} for pdu {pdu}".format(
yellow=colors.YELLOW,
task_name=task_name,
normal=colors.NORMAL,
pdu=self.pdu))
self.__tasks_queue.put((task_name, func, args))
def handle_outlet(self, args):
outlet = args[0]
action = args[1]
logger.info("handle outlet {0}/{1}, action: {2}".format(
outlet, self.pdu, self.actions[int(action)]))
on_offset = self.pduouton_oid_offset + "." + str(self.to_pdu(self.pdu))
action_in_oid = self.extract(self.get_outlet_field(on_offset, outlet))
logger.warn("action: {0}, action_in_oid: {1}".format(
self.actions[int(action)], self.actions[int(action_in_oid)]))
vmname = self.__node_control_handler.get_node_name(
int(self.pdu), int(outlet))
if vmname is None:
logger.error("No virtual node found for outlet {0}".format(outlet))
return
datastore = self.__node_control_handler.get_node_datastore(vmname)
if datastore is None:
logger.error(
"No datastore found for virtual node {0}".format(vmname))
return
# Make sure the action as the last one
logger.info("last action: {0}, current action: {1}".format(
self.action_list[int(outlet) - 1], self.actions[int(action)]))
if self.action_list[int(outlet) - 1] == self.actions[int(action)]:
logger.warn("No need to execute action for {0}/{1}".format(
outlet, self.pdu))
return
if self.actions[int(action)] == 'on':
status = self.__node_control_handler.power_on_node(
datastore, vmname)
elif self.actions[int(action)] == 'off':
status = self.__node_control_handler.power_off_node(
datastore, vmname)
elif self.actions[int(action)] == 'reboot':
status = self.__node_control_handler.reboot(datastore, vmname)
else:
logger.error("Unknown action: {0}".format(action))
if status != 0:
logger.error("Failed to {0} virtual node.".format(
self.actions[int(action)]))
return
self.action_list[int(outlet) - 1] = self.actions[int(action)]
def handle_message(self, message):
oid = message.split()[0]
outlet = oid.split('.')[-1]
value = message.split()[1]
logger.info("Handle message {0}".format(message))
if message.startswith(self.pduouton_oid_offset):
self.add_task("handle_outlet-{0}".
format(outlet), self.handle_outlet,
int(outlet), value)
elif message.startswith(self.pduoutpwd_oid_offset):
self.add_task("handle_password-{0}".
format(outlet), self.handle_password,
int(outlet), value)
else:
logger.warn("{0} is not handled now.".format(message))
def write_password(pdu, port, password):
_content = ''
try:
matched = False
password_file = config.get_conf_instance().password_file
fd = open(password_file, 'r+')
lines = fd.readlines()
fd.close()
for line in lines:
# Ignore blank line
if line == os.linesep:
_content += line
continue
# Ignore comments which begins with '#'
result_obj = re.search(r"^#.*", line)
if result_obj:
_content += line
continue
l = line.split(':')
# If the password is already in configuration file, then update it.
if pdu == int(l[1]) and port == int(l[2]):
matched = True
# Update password
line = ':'.join([str(time.time()), str(pdu),
str(port), str(password)])
line += os.linesep
logger.info("Update password %s for PDU %d port %d" %
(password, pdu, port))
_content += line
# If the pdu and port have not been assigned a password,
# then added the password
if not matched:
new_line = ':'.join([str(time.time()), str(pdu),
str(port), str(password)])
new_line += os.linesep
_content = _content + new_line
logger.info("Add password %s for PDU %d port %d" %
(password, pdu, port))
# Write the password settings back to the configuration file
fd = open(config.get_conf_instance().password_file, 'w')
fd.writelines(_content)
fd.close()
except IOError as e:
logger.error("Error in open password file.exception: {}".format(e))
def run(self):
while self.__running:
try:
task_name, func, args = self.__tasks_queue.get()
logger.info("Running task ... {peachblow}{task_name}{normal} \
on thread {threadname}".
format(peachblow=colors.PEACHBLOW,
task_name=task_name,
normal=colors.NORMAL,
threadname=self.getName()))
func(args)
self.__tasks_queue.task_done()
logger.info("{cyan}{task_name}{normal} Done".
format(cyan=colors.CYAN,
task_name=task_name,
normal=colors.NORMAL))
except Exception, ex:
logger.error("{0}: {1}".
format(sys._getframe().f_code.co_name, ex))
def run(self):
while self.__running:
try:
task_name, func, args = self.__tasks_queue.get()
logger.info("Running task ... {peachblow}{task_name}{normal} \
on thread {threadname}".format(
peachblow=colors.PEACHBLOW,
task_name=task_name,
normal=colors.NORMAL,
threadname=self.getName()))
func(args)
self.__tasks_queue.task_done()
logger.info("{cyan}{task_name}{normal} Done".format(
cyan=colors.CYAN,
task_name=task_name,
normal=colors.NORMAL))
except Exception, ex:
logger.error("{0}: {1}".format(sys._getframe().f_code.co_name,
ex))
def __init__(self):
'''
Constructor
'''
super(VMwareHandler, self).__init__()
self.__host_ip = None
self.__username = None
self.__password = None
self.set_esxi_host_info()
if self.__host_ip is not None:
self.__ssh = sshclient.SSH(self.__host_ip, self.__username,
self.__password)
self.__ssh.connect()
if self.__ssh.connected() is False:
logger.error("Connection error for {0}@{1}".
format(self.__username, self.__host_ip))
else:
logger.info("Connection ok for {0}@{1}".
format(self.__username, self.__host_ip))
else:
logger.warn("ESXi is not set in configuration file.")
def __init__(self):
'''
Constructor
'''
super(VMwareHandler, self).__init__()
self.__host_ip = None
self.__username = None
self.__password = None
self.set_esxi_host_info()
if self.__host_ip is not None:
self.__ssh = sshclient.SSH(self.__host_ip, self.__username,
self.__password)
self.__ssh.connect()
if self.__ssh.connected() is False:
logger.error("Connection error for {0}@{1}".format(
self.__username, self.__host_ip))
else:
logger.info("Connection ok for {0}@{1}".format(
self.__username, self.__host_ip))
else:
logger.warn("ESXi is not set in configuration file.")
def start(self):
if not os.path.exists('/usr/bin/snmpsimd.py') \
and not os.path.exists('/bin/snmpsimd.py') \
and not os.path.exists('/usr/local/bin/snmpsimd.py'):
logger.error("snmpsimd.py does not exist!")
return -1
if self.__alive():
self.stop()
if not os.path.exists("/var/run/snmpsim"):
os.mkdir("/var/run/snmpsim")
if not os.path.exists("/var/log/snmpsim"):
os.mkdir("/var/log/snmpsim")
data_dir = self.__config_instance.snmp_data_dir
db_path = os.path.join(data_dir, self.__config_instance.db_file)
args_list = ["snmpsimd.py"]
endpoint_param = "--agent-udpv4-endpoint=0.0.0.0"
args_list.append(endpoint_param)
process_user = "******"
args_list.append(process_user)
process_group = "--process-group=root"
args_list.append(process_group)
logging_option = "--logging-method=file:/var/log/snmpsim/snmpsimd.log"
args_list.append(logging_option)
pid_option = "--pid-file=" + snmpsim_pid_file
args_list.append(pid_option)
daemonize_option = "--daemonize"
args_list.append(daemonize_option)
data_dir_option = "--data-dir=" + data_dir
args_list.append(data_dir_option)
if self.__db_type == "SQLITE":
variation_modules_dir = "--variation-modules-dir=" + \
self.__config_instance.variation_modules_dir
args_list.append(variation_modules_dir)
sql_option = "--variation-module-options=sql:dbtype:sqlite3,database:" + db_path
args_list.append(sql_option)
elif self.__db_type == "WRITECACHE":
writecache_option = "--variation-module-options=writecache:file:" + db_path
args_list.append(writecache_option)
else:
return -1
logger.info("Start snmpsimd service for {0}.".format(self.__pdu_name))
logger.info(' '.join(args_list))
retcode = subprocess.call(args_list)
if retcode != 0:
return -1
time.sleep(1)
pid = self.getpid()
if pid < 0:
logger.error("Failed to start snmpsim service!")
return -1
logger.info("Succeed to start snmpsim service, pid: %d." % pid)
return 0
def poll(self, session, timeout=30, indata=[]):
session.setblocking(0)
index = 0
timeout_flag = False
start = time.mktime(datetime.datetime.now().timetuple())
output = ''
while True:
if session.recv_ready():
data = session.recv(self.buffer_size)
output += data
if session.send_ready():
if index < len(indata):
data = indata[index] + '\n'
index += 1
logger.info("sending {0} bytes data".format(len(data)))
session.send(data)
if session.exit_status_ready():
break
now = time.mktime(datetime.datetime.now().timetuple())
delta = now - start
if delta > timeout:
timeout_flag = True
break
time.sleep(0.5)
if session.recv_ready():
data = session.recv(self.buffer_size)
output += data
logger.info("1: Got {0} bytes, total {1} bytes".
format(len(data), len(output)))
if timeout_flag:
output += '\nError: timeout after {0} seconds\n'.format(timeout)
return output
def read_password(pdu, port):
try:
password_file = config.get_conf_instance().password_file
fd = open(password_file, 'r')
while True:
line = fd.readline()
if not line:
break
# Ignore blank line
if line == os.linesep:
continue
# Ignore comments which begins with "#"
result_obj = re.search(r"^#.*", line)
if result_obj:
continue
# The format should be:
# <timestamp> <pdu number> <pdu port> <password>
l = line.strip(os.linesep).split(':')
try:
lpdu = int(l[1])
lport = int(l[2])
except ValueError:
logger.error("Converting int or float error from string.")
return ""
password = l[3]
if lpdu == pdu and lport == port:
fd.close()
logger.info("Return password %s for PDU %d port %d" %
(password, pdu, port))
return password
fd.close()
logger.error("Not found password for PDU %d port %d" % (pdu, port))
return ""
except IOError as e:
logger.error("Error in open password file.exception: {}".format(e))
return ""
def poll(self, session, timeout=30, indata=[]):
session.setblocking(0)
index = 0
timeout_flag = False
start = time.mktime(datetime.datetime.now().timetuple())
output = ''
while True:
if session.recv_ready():
data = session.recv(self.buffer_size)
output += data
if session.send_ready():
if index < len(indata):
data = indata[index] + '\n'
index += 1
logger.info("sending {0} bytes data".format(len(data)))
session.send(data)
if session.exit_status_ready():
break
now = time.mktime(datetime.datetime.now().timetuple())
delta = now - start
if delta > timeout:
timeout_flag = True
break
time.sleep(0.5)
if session.recv_ready():
data = session.recv(self.buffer_size)
output += data
logger.info("1: Got {0} bytes, total {1} bytes".format(
len(data), len(output)))
if timeout_flag:
output += '\nError: timeout after {0} seconds\n'.format(timeout)
return output
def exec_command(self, cmd, indata=None, timeout=30):
logger.info("Executing command: {0}".format(cmd))
if self.transport is None or self.transport.is_active() is False:
self.reconnect()
if self.transport is None or self.transport.is_active() is False:
logger.error("connection failed.")
return -1, None
input_data = self.__fix_indata(indata)
try:
session = self.transport.open_session()
session.set_combine_stderr(True)
session.get_pty()
session.exec_command(cmd)
except paramiko.SSHException as ex:
logger.error("Exception for command '{0}: {1}'".format(cmd, ex))
session.close()
return -1, None
output = self.poll(session, timeout, input_data)
status = session.recv_exit_status()
logger.info("Returned status {0}".format(status))
session.close()
return status, output
def exec_command(self, cmd, indata=None, timeout=30):
logger.info("Executing command: {0}".format(cmd))
if self.transport is None or self.transport.is_active() is False:
self.reconnect()
if self.transport is None or self.transport.is_active() is False:
logger.error("connection failed.")
return -1, None
input_data = self.__fix_indata(indata)
try:
session = self.transport.open_session()
session.set_combine_stderr(True)
session.get_pty()
session.exec_command(cmd)
except paramiko.SSHException as ex:
logger.error("Exception for command '{0}: {1}'".format(cmd, ex))
session.close()
return -1, None
output = self.poll(session, timeout, input_data)
status = session.recv_exit_status()
logger.info("Returned status {0}".format(status))
session.close()
return status, output
def power_off_node(self, *args):
'''
Power off VM with ESXi CLI
'''
datastore = args[0]
vmname = args[1]
logger.info("Power off " + datastore + "/" + vmname + "...")
command = self.__build_command(datastore, vmname, "getstate")
status, ret = self.__execute_command(command)
if status != 0:
logger.error("Command failed, status : {0}".format(status))
return status
if "off" in ret:
logger.info("%s already is off." % vmname)
return 0
command = self.__build_command(datastore, vmname, "off")
status, ret = self.__execute_command(command)
if status != 0:
logger.error("Command failed, status : {0}".format(status))
return status
logger.info(ret.strip())
return 0
def power_off_node(self, *args):
'''
Power off VM with ESXi CLI
'''
datastore = args[0]
vmname = args[1]
logger.info("Power off " + datastore + "/" + vmname + "...")
command = self.__build_command(datastore, vmname, "getstate")
status, ret = self.__execute_command(command)
if status != 0:
logger.error("Command failed, status : {0}".format(status))
return status
if "off" in ret:
logger.info("%s already is off." % vmname)
return 0
command = self.__build_command(datastore, vmname, "off")
status, ret = self.__execute_command(command)
if status != 0:
logger.error("Command failed, status : {0}".format(status))
return status
logger.info(ret.strip())
return 0
rlist.append(self.__pipe.inform)
timeout = 10
try:
while self.__running:
readable, _, _ = select.select(rlist, [], [], timeout)
if not readable:
continue
if self.__pipe.inform in readable:
try:
message = self.__pipe.read(256)
except OSError, exc:
logger.warn("[Error %d] appeared at reading pipe" %
exc.errno)
continue
if len(message) == 0:
continue
self.handle_message(message)
except KeyboardInterrupt:
logger.error("Break by user.")
except Exception, ex:
logger.error("{0}: {1}".format(sys._getframe().f_code.co_name, ex))
finally:
logger.info("vSentry service exits.")
self.__pipe.close()
def stop(self):
self.__running = False
def signal_handler(signum, frame):
logger.info("Signal {0} receivced.".format(signum))
if pdu_sim is not None and pdu_sim.is_alive():
pdu_sim.stop()
logger.info("vPDU exit.")
sys.exit(0)
def command_vpdu(self, params):
'''[<start/stop/restart/status>]
Control vpdu service and get vpdu service status.
vpdu start - Start vPDU and SNMP simulator service
vpdu stop - Stop vPDU and SNMP simulator service
vpdu restart - Restart vPDU and SNMP simulator service
vpdu status - Get vPDU and SNMP simulator status
'''
if len(params) == 0:
return
global pdu_sim
logger.info("Executing action: %s" % params[0])
if params[0] == 'start':
if pdu_sim.is_alive():
self.writeresponse("%svpdu service [%d] is alredy running.%s"
% (colors.GREEN, pdu_sim.pid, colors.NORMAL))
else:
pdu_sim = pdusim.pdusim.PDUSim()
pdu_sim.set_daemon()
pdu_sim.start()
time.sleep(1)
if pdu_sim.is_alive():
self.writeresponse("%svpdu service [%d] is started.%s"
% (colors.GREEN, pdu_sim.pid, colors.NORMAL))
elif params[0] == 'stop':
if not pdu_sim.is_alive():
self.writeresponse("%svpdu service is already stopped.%s"
% (colors.GREEN, colors.NORMAL))
return
if pdu_sim.is_alive():
pdu_sim.stop()
time.sleep(1)
if not pdu_sim.is_alive():
self.writeresponse("%svpdu service is stopped.%s"
% (colors.GREEN, colors.NORMAL))
elif params[0] == 'restart':
if pdu_sim.is_alive():
pdu_sim.stop()
# Wait 1 second for snmpsim exit, and then end then check again
time.sleep(1)
if pdu_sim:
pdu_sim = pdusim.pdusim.PDUSim()
pdu_sim.set_daemon()
pdu_sim.start()
time.sleep(1)
if pdu_sim.is_alive():
self.writeresponse("%svpdu service [%d] is restarted.%s"
% (colors.GREEN, pdu_sim.pid, colors.NORMAL))
logger.info("vpdu service [%d] is restarted." % pdu_sim.pid)
return
logger.error("Cannot restart vpdu service.")
elif params[0] == 'status':
if pdu_sim.is_alive() is True:
response = "%svpdu service [%d] is running.%s" % \
(colors.GREEN, pdu_sim.pid, colors.NORMAL)
self.writeresponse(response)
logger.info(response)
else:
if pdu_sim.is_alive() is False:
response = \
"%svpdu service is not running.%s" % (colors.RED,
colors.NORMAL)
self.writeresponse(response)
logger.info(response)
def command_config(self, params):
'''<esxi|pdu> [<list/update/add/delete> | <set/get>] [<param.1> ... < param.n>]
configure vPDU
----------------------------------
config pdu set <name>
- set PDU name
e.g.
config pdu set hawk
config pdu set database <database file>
- set pdu database file name
e.g.
config pdu set database ipia.db
config pdu set datadir <snmp data dir>
- set snmp data directory name
e.g.
config pdu set datadir hawk
config pdu list
-list pdu configurations
config esxi
--------------------------------------
config esxi list
- list configuration
config esxi update <option name> <value>
- update configuration
e.g.
Update esxi ip address in configuration file, run below command:
config esxi update host 10.62.59.124
Update esxi host "username"
config esxi update uesrname root
Update esxi host "password"
config esxi update password root
config esxi add <host> <uesrname> <password>
- add configuration
e.g.
Add an ESXi host information including ip, username and passowrd
config esxi add 10.62.59.128 root 1234567
config esxi delete
- delete configuration
e.g.
Delete section "esxihost"
config esxi delete esxihost
Note: After update/add the configuration, please run 'config list' to
be sure that the changes you made are correct.
'''
if len(params) == 0:
return
if params[0] == "pdu":
if params[1] == 'set':
if params[2] == 'name':
self.config_instance.pdu_name = params[3]
elif params[2] == 'database':
self.config_instance.db_file = params[3]
elif params[2] == 'datadir':
self.config_instance.snmp_data_dir = params[3]
self.config_instance.update()
elif params[1] == 'get':
self.config_instance.init()
table = Texttable()
table.add_row(['name', self.config_instance.pdu_name])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmp data dir',
self.config_instance.snmp_data_dir])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
elif params[1] == 'list':
self.config_instance.init()
table = Texttable()
table.add_row(['pdu name', self.config_instance.pdu_name])
table.add_row(['dbtype', self.config_instance.db_type])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmpdata', self.config_instance.snmp_data_dir])
table.add_row(['simfile', self.config_instance.sim_file])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
else:
logger.error("Unknown command {0}".format(params[0]))
elif params[0] == "esxi":
if params[1] == "list":
self.config_instance.init()
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
table = Texttable()
table.header(["esxi host", "username", "password"])
table.add_row([
get_color_string(bcolors.GREEN, esxi_info['host']),
get_color_string(bcolors.GREEN, esxi_info["username"]),
get_color_string(bcolors.GREEN, esxi_info['password'])
])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
return
else:
self.writeresponse("%sNo ESXi host info in configuration \
file.%s" % (colors.RED, colors.NORMAL))
elif params[1] == "update":
if len(params[2:]) == 2:
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
esxi_info[params[2]] = params[3]
self.config_instance.update()
else:
self.writeresponse("%sNo %s found in configuration \
file.%s" % (colors.RED, params[1], colors.NORMAL))
elif params[1] == "add":
if len(params[2:]) != 3:
return
if self.config_instance.esxi_info is None:
esxi_info = {}
logger.info("Adding esxi host: {0}, {1}, {2}"
.format(params[2], params[3], params[4]))
esxi_info['host'] = params[2]
esxi_info['username'] = params[3]
esxi_info['password'] = params[4]
self.config_instance.esxi_info = esxi_info
self.config_instance.update()
else:
self.writeresponse("ESXi info already exists.")
elif params[1] == "delete":
if self.config_instance.esxi_info is not None:
self.config_instance.delete()
else:
self.writeresponse("ESXi info already deleted.")
else:
self.writeresponse("unknown parameters.")
else:
self.writeresponse("unknown parameters: {0}.".format(params[0]))
logger.initialize("pdusim", "stdout")
try:
opts, args = getopt.getopt(sys.argv[1:],
"dh",
["daemonize", "help", "logging-method="])
for opt, arg in opts:
if opt in ("-h", "--help"):
usage()
sys.exit(1)
elif opt in ("-d", "--daemonize"):
daemon = True
elif opt == "--logging-method":
logger.initialize("pdusim", *arg.split(':'))
except getopt.GetoptError:
usage()
sys.exit(1)
if daemon:
pdusim.common.daemon.daemonize(server_pid_file)
logger.info("vPDU started")
init_signal()
pdu_sim = pdusim.pdusim.PDUSim()
pdu_sim.set_daemon()
pdu_sim.start()
logger.info("PDU service PID: {}".format(pdu_sim.pid))
logger.info("Server started")
server = vPDUHandler()
server.serve_forever()
def command_vpdu(self, params):
'''[<start/stop/restart/status>]
Control vpdu service and get vpdu service status.
vpdu start - Start vPDU and SNMP simulator service
vpdu stop - Stop vPDU and SNMP simulator service
vpdu restart - Restart vPDU and SNMP simulator service
vpdu status - Get vPDU and SNMP simulator status
'''
if len(params) == 0:
return
global pdu_sim
logger.info("Executing action: %s" % params[0])
if params[0] == 'start':
if pdu_sim.is_alive():
self.writeresponse("%svpdu service [%d] is alredy running.%s" %
(colors.GREEN, pdu_sim.pid, colors.NORMAL))
else:
pdu_sim = pdusim.pdusim.PDUSim()
pdu_sim.set_daemon()
pdu_sim.start()
time.sleep(1)
if pdu_sim.is_alive():
self.writeresponse(
"%svpdu service [%d] is started.%s" %
(colors.GREEN, pdu_sim.pid, colors.NORMAL))
elif params[0] == 'stop':
if not pdu_sim.is_alive():
self.writeresponse("%svpdu service is already stopped.%s" %
(colors.GREEN, colors.NORMAL))
return
if pdu_sim.is_alive():
pdu_sim.stop()
time.sleep(1)
if not pdu_sim.is_alive():
self.writeresponse("%svpdu service is stopped.%s" %
(colors.GREEN, colors.NORMAL))
elif params[0] == 'restart':
if pdu_sim.is_alive():
pdu_sim.stop()
# Wait 1 second for snmpsim exit, and then end then check again
time.sleep(1)
if pdu_sim:
pdu_sim = pdusim.pdusim.PDUSim()
pdu_sim.set_daemon()
pdu_sim.start()
time.sleep(1)
if pdu_sim.is_alive():
self.writeresponse(
"%svpdu service [%d] is restarted.%s" %
(colors.GREEN, pdu_sim.pid, colors.NORMAL))
logger.info("vpdu service [%d] is restarted." %
pdu_sim.pid)
return
logger.error("Cannot restart vpdu service.")
elif params[0] == 'status':
if pdu_sim.is_alive() is True:
response = "%svpdu service [%d] is running.%s" % \
(colors.GREEN, pdu_sim.pid, colors.NORMAL)
self.writeresponse(response)
logger.info(response)
else:
if pdu_sim.is_alive() is False:
response = \
"%svpdu service is not running.%s" % (colors.RED,
colors.NORMAL)
self.writeresponse(response)
logger.info(response)
sys.exit(1)
if daemon:
pdusim.common.daemon.daemonize(server_pid_file)
init_signal()
# report_ip_thread = threading.Thread(target = pdusim.reportip.rptClient)
# report_ip_thread.start()
# Find the conf home dir
for dir in install_data_dir:
path = os.path.join(dir, 'conf', 'host.conf')
if os.path.exists(path):
config_home_dir = dir
break
if config_home_dir == "":
logger.error("Cann't find conf dir.")
sys.exit(1)
conf = config.Config(config_home_dir)
config.set_conf_instance(conf)
mapping_file.set_mapping_file_handle(
mapping_file.MappingFileHandle(config_home_dir)
)
logger.info("Server started")
server = vPDUHandler()
server.serve_forever()
def command_config(self, params):
'''<esxi|pdu> [<list/update/add/delete> | <set/get>] [<param.1> ... < param.n>]
configure vPDU
----------------------------------
config pdu set <name>
- set PDU name
e.g.
config pdu set hawk
config pdu set database <database file>
- set pdu database file name
e.g.
config pdu set database ipia.db
config pdu set datadir <snmp data dir>
- set snmp data directory name
e.g.
config pdu set datadir hawk
config pdu list
-list pdu configurations
config esxi
--------------------------------------
config esxi list
- list configuration
config esxi update <option name> <value>
- update configuration
e.g.
Update esxi ip address in configuration file, run below command:
config esxi update host 10.62.59.124
Update esxi host "username"
config esxi update uesrname root
Update esxi host "password"
config esxi update password root
config esxi add <host> <uesrname> <password>
- add configuration
e.g.
Add an ESXi host information including ip, username and passowrd
config esxi add 10.62.59.128 root 1234567
config esxi delete
- delete configuration
e.g.
Delete section "esxihost"
config esxi delete esxihost
Note: After update/add the configuration, please run 'config list' to
be sure that the changes you made are correct.
'''
if len(params) == 0:
return
if params[0] == "pdu":
if params[1] == 'set':
if params[2] == 'name':
self.config_instance.pdu_name = params[3]
elif params[2] == 'database':
self.config_instance.db_file = params[3]
elif params[2] == 'datadir':
self.config_instance.snmp_data_dir = params[3]
self.config_instance.update()
elif params[1] == 'get':
self.config_instance.init()
table = Texttable()
table.add_row(['name', self.config_instance.pdu_name])
table.add_row(['database', self.config_instance.db_file])
table.add_row(['snmp data dir',
self.config_instance.snmp_data_dir])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
else:
logger.error("Unknown command {0}".format(params[0]))
elif params[0] == "esxi":
if params[1] == "list":
self.config_instance.init()
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
table = Texttable()
table.header(["esxi host", "username", "password"])
table.add_row([
get_color_string(bcolors.GREEN, esxi_info['host']),
get_color_string(bcolors.GREEN, esxi_info["username"]),
get_color_string(bcolors.GREEN, esxi_info['password'])
])
table_str = table.draw()
self.writeresponse(table_str)
logger.info("\n" + table_str)
return
else:
self.writeresponse("%sNo ESXi host info in configuration \
file.%s" % (colors.RED, colors.NORMAL))
elif params[1] == "update":
if len(params[2:]) == 2:
esxi_info = self.config_instance.esxi_info
if esxi_info is not None:
esxi_info[params[2]] = params[3]
self.config_instance.update()
else:
self.writeresponse("%sNo %s found in configuration \
file.%s" % (colors.RED, params[1], colors.NORMAL))
elif params[1] == "add":
if len(params[2:]) != 3:
return
if self.config_instance.esxi_info is None:
esxi_info = {}
logger.info("Adding esxi host: {0}, {1}, {2}"
.format(params[2], params[3], params[4]))
esxi_info['host'] = params[2]
esxi_info['username'] = params[3]
esxi_info['password'] = params[4]
self.config_instance.esxi_info = esxi_info
self.config_instance.update()
else:
self.writeresponse("ESXi info already exists.")
elif params[1] == "delete":
if self.config_instance.esxi_info is not None:
self.config_instance.delete()
else:
self.writeresponse("ESXi info already deleted.")
else:
self.writeresponse("unknown parameters.")
else:
self.writeresponse("unknown parameters: {0}.".format(params[0]))
def command_vpdu(self, params):
'''[<start/stop/restart/status>]
Control vpdu service and get vpdu service status.
vpdu start - Start vPDU and SNMP simulator service
vpdu stop - Stop vPDU and SNMP simulator service
vpdu restart - Restart vPDU and SNMP simulator service
vpdu status - Get vPDU and SNMP simulator status
'''
if len(params) == 0:
return
logger.info("Executing action: %s" % params[0])
if params[0] == 'start':
pid = get_vpdu_pid()
logger.info("vpdu pid: %d" % pid)
if pid > 0:
self.writeresponse("%svpdu service [%d] is alredy running.%s"
% (colors.GREEN, pid, colors.NORMAL))
else:
ret = start_vpdu()
if ret == 0:
pid = get_vpdu_pid()
if pid > 0:
self.writeresponse("%svpdu service [%d] is started.%s"
% (colors.GREEN, pid, colors.NORMAL))
return
else:
# check if the snmpsim service is already running.
snmpsim_pid = SNMPSimService.getpid()
if snmpsim_pid > 0:
os.kill(snmpsim_pid, signal.SIGTERM)
self.writeresponse("%sFailed to start vpdu service.%s"
% (colors.RED, colors.NORMAL))
logger.error("Failed to start vpdu service.")
elif params[0] == 'stop':
pid = get_vpdu_pid()
if pid < 0:
self.writeresponse("%svpdu service is already stopped.%s"
% (colors.GREEN, colors.NORMAL))
return
if pid > 0:
os.kill(pid, signal.SIGTERM)
# Wait 1 second for snmpsim exit, and then end then check again
time.sleep(1)
snmpsim_pid = SNMPSimService.getpid()
if snmpsim_pid > 0:
os.kill(snmpsim_pid, signal.SIGTERM)
pid = get_vpdu_pid()
snmpsim_pid = SNMPSimService.getpid()
if pid < 0 and snmpsim_pid < 0:
self.writeresponse("%svpdu service is stopped.%s"
% (colors.GREEN, colors.NORMAL))
else:
self.writeresponse("%sCannot stop vpdu service.vpdu pid %d, \
snmpsim pid %d.%s"
% (colors.RED, pid, snmpsim_pid,
colors.NORMAL))
logger.error("Cannot stop vpdu service. vpdu pid %d, \
snmpsim pid %d" % (pid, snmpsim_pid))
elif params[0] == 'restart':
pid = get_vpdu_pid()
if pid > 0:
os.kill(pid, signal.SIGTERM)
# Wait 1 second for snmpsim exit, and then end then check again
time.sleep(1)
snmpsim_pid = SNMPSimService.getpid()
if snmpsim_pid > 0:
os.kill(snmpsim_pid, signal.SIGTERM)
self.writeresponse("{0}vpdu service is stopped.{1}"
.format(colors.GREEN, colors.NORMAL))
logger.info("vpdu service is stopped.")
ret = start_vpdu()
if ret == 0:
pid = get_vpdu_pid()
snmpsim_pid = SNMPSimService.getpid()
if pid > 0 and snmpsim_pid > 0:
self.writeresponse("{0}vpdu service [{1}] is restarted.{2}"
.format(colors.GREEN, pid, colors.NORMAL)
)
logger.info("vpdu service [%d] is restarted." % pid)
return
self.writeresponse("{0}Cannot restart vpdu service. pid {1}, \
snmpsimd pid {2}{3}".format(colors.RED, pid,
snmpsim_pid,
colors.NORMAL)
)
logger.error("Cannot restart vpdu service.")
elif params[0] == 'status':
vpdu_pid = get_vpdu_pid()
snmpsim_pid = SNMPSimService.getpid()
response = ""
if vpdu_pid > 0 and snmpsim_pid > 0:
response = "%svpdu service [%d] is running.%s" % \
(colors.GREEN, vpdu_pid, colors.NORMAL)
self.writeresponse(response)
logger.info(response)
elif vpdu_pid < 0 and snmpsim_pid < 0:
response = \
"%svpdu service is not running.%s" % (colors.RED,
colors.NORMAL)
self.writeresponse(response)
logger.info(response)
else:
response = "{0}There is an exception, \
vpdu pid {1}, snmp sim pid {2}.{3}"\
.format(colors.RED, vpdu_pid, snmpsim_pid, colors.NORMAL)
self.writeresponse(response)
logger.info(response)
def signal_handler(signum, frame):
logger.info("Signal {0} receivced.".format(signum))
if pdu_sim is not None and pdu_sim.is_alive():
pdu_sim.stop()
logger.info("vPDU exit.")
sys.exit(0)
