def element_is_displayed(self, keys):
try:
element = self.get_element(keys)
if element is not None:
element.is_displayed()
except BaseException, e:
Log.error(e)
def wait_unit_el_present(self, keys, sec=15):
"""
Display wait,wait until element display, time out 15 sec
"""
wait = WebDriverWait(self.driver, sec)
key = keys[0]
value = keys[1]
if key in ['XPATH', 'xpath']:
locator = (By.XPATH, value)
elif key in ['link_text', 'LINK_TEXT']:
locator = (By.LINK_TEXT, value)
elif key in ['ID', 'id']:
locator = (By.ID, value)
elif key in ['NAME', 'name']:
locator = (By.NAME, value)
elif key in ['CLASS_NAME', 'class_name']:
locator = (By.CLASS_NAME, value)
elif key in ['TAG', 'tag']:
locator = (By.TAG_NAME, value)
try:
element = wait.until(ec.presence_of_element_located(locator))
return element
except BaseException, e:
Log.error(e)
self.get_windows_img()
return None
def wait_for_page_changes(driver,
page_title_to_change_to,
wait_for_seconds=60):
"""
wait_for_page_changes
Waits for an page to change, subject to timeout specified in wait_for_seconds
:param driver: Webdriver controller for the web page
:param page_title_to_change_to: Title of the page we want to go to.
:param wait_for_seconds: Timeout value for the page to change to the desired page title
"""
Log.info(f"Current page title is {driver.title}")
Log.info(
f"Waiting {wait_for_seconds} seconds for page to change to {page_title_to_change_to}"
)
try:
WebDriverWait(driver, wait_for_seconds).until(
expected_conditions.title_contains(page_title_to_change_to))
except TimeoutException as e:
Log.error(f"Timed out with page title at {driver.title}")
take_screenshot(driver)
driver.quit()
raise TimeoutException(
f"Timed out with page title at {driver.title}. {e}")
Log.info(f"Page has changed to {page_title_to_change_to}")
def click_menu(self, menuname):
"""
Click ADMIN page menu
"""
Log.info("Click the % s menu")
if menuname == "Configure":
newmenu = "menu_performance_{}".format("Configure")
elif menuname == "KPIs":
newmenu = "menu_performance_searchKpi"
elif menuname == "Trackers":
newmenu = "menu_performance_addPerformanceTracker"
elif menuname == "Manage Reviews":
newmenu = "menu_performance_ManageReviews"
elif menuname == "Employee Trackers":
newmenu = "menu_performance_viewEmployeePerformanceTrackerList"
else:
newmenu = "menu_performance_{}".format(menuname)
menu = self.menuBar.format(newmenu)
try:
element = self.wait_unit_el_present(("xpath", menu))
element.click()
except BaseException, e:
print e
Log.error(e)
raise "Element %s not found" % menuname
def candidates_edit_status(self, vacan_name, status, status_reason):
"""
Test Change the candidate's vacancy status to reject Function
1. click edit button
2. change status to reject
3. input reject reason
4. validate the status
"""
rcandi_xpath = self.rcandi_xpath.format(vacan_name)
rcandi = ('xpath', rcandi_xpath)
candi_rec = self.get_element(rcandi)
if candi_rec is not None:
self.click(rcandi)
self.click(self.save_btn)
self.set_combox_value(status, self.action)
self.clear_text(self.status_reason)
self.input_text(status_reason, self.status_reason)
self.click(self.status_btn)
self.click(self.back_btn)
self.click_menu('Candidates')
status_xpath = self.status_xpath.format(vacan_name, )
status = ('xpath', status_xpath)
assert 'Rejected' == self.get_element_text(status)
else:
Log.error("Unable to locate the candidate record")
def fail(self, data={}, info=""):
"""请求返回失败"""
if not isinstance(data, dict):
data = {}
frame = inspect.stack()[1].frame
Log.error(f"{self.fail.__doc__} {call_me(frame)} {data} {info}")
return JResponse(msg="FAIL", code=-1, info=info, data=data)
def press_enter_key(self, keys):
"""
Todo need test later
"""
try:
self.get_element(keys).send_keys(Keys.ENTER)
except BaseException, e:
Log.error(e)
def open_immigration_page_via_creating_emp(self, first_name, last_name):
"""
Go to Immigration page via creating an employee
"""
try:
self.add_employee(first_name, last_name)
except Exception, e:
Log.error(e)
def get_all_window(self):
"""
Get current window page
"""
try:
return self.driver.window_handles
except BaseException, e:
Log.error(e)
def input_random_number(*args):
try:
if len(args) == 0:
number_length = randrange(4, 8)
else:
number_length = args[0]
number = ''.join(choice(dig) for _ in range(number_length))
except Exception, e:
Log.error("% s, please transfer one digit param." % e)
def get_page_url(self):
"""
Get page title
"""
try:
Log.info("Current page title is %s" % self.driver.current_url)
return self.driver.current_url
except BaseException, e:
Log.error(e)
def select_option(self, keys, option):
"""
select option
"""
try:
value = Select(self.get_element(keys)).select_by_index(option)
return value
except BaseException, e:
Log.error(e)
def get_first_select(self, keys):
"""
get select option first value
"""
try:
value1 = Select(self.get_element(keys)).first_selected_option.text
return value1
except BaseException, e:
Log.error(e)
def input_random_password(*args):
try:
if len(args) == 0:
password_length = randrange(4, 8)
else:
password_length = args[0]
password = ''.join(
choice(lc + up + dig + pun) for _ in range(password_length))
except Exception, e:
Log.error("% s, please transfer one digit param." % e)
def input_random_text(*args):
try:
if len(args) == 0:
text_length = randrange(4, 8)
else:
text_length = args[0]
text = ''.join(choice(lc) for _ in range(text_length))
except Exception, e:
Log.error("% s, please transfer one digit param." % e)
text = text.capitalize()
def mouse_move_to_element(self, keys):
"""
Mouse move to the element - Added by Linda
"""
try:
mouse = self.get_element(keys)
if mouse is not None:
ActionChains(self.driver).move_to_element(mouse).perform()
except BaseException, e:
Log.error(e)
def switch_employee_detail_page(self, tab_name):
"""
Switch any Employee Details page - added by Linda
"""
try:
tab = self.tab_ele.format(tab_name)
self.click(('xpath', tab))
except BaseException, e:
print e
Log.error(e)
raise "Element %s not found" % tab_name
def get_random_data(self, keys):
"""
Get random data - Added by Linda
"""
try:
elements = self.get_elements(keys)
element = choice(elements)
element_text = element.text
return element_text
except Exception, e:
Log.error(e)
def get(self, *args, **kwargs):
try:
self._get(*args, **kwargs)
except Exception, e:
Log.error(e)
self.render('500.htm', next_url=self.request.uri)
def post(self, *args, **kwargs):
try:
self._post(*args, **kwargs)
except Exception, e:
Log.error(e)
self.write('Error')
def click_menu(self, menuname):
"""
Click ADMIN page menu
"""
Log.info("Click the % s menu")
menu_name = menuname.title()
try:
element = self.get_element(("link_text", menu_name))
element.click()
except BaseException, e:
print e
Log.error(e)
def clear_text(self, keys):
"""
Clear the text box
"""
try:
element = self.get_element(keys)
if element is None:
return None
else:
self.get_element(keys).clear()
except BaseException, e:
Log.error(e)
def click(self, keys):
"""
Click button
"""
try:
element = self.get_element(keys)
if element is None:
raise Exception
else:
self.get_element(keys).click()
except BaseException, e:
Log.error(e)
def open_immigration_page_via_editing_emp(self):
"""
Go to Immigration page via editing an employee
"""
try:
select_data = self.get_random_data(self.select_ele)
click_ele = self.click_selected_ele.format(select_data)
self.click(('xpath', click_ele))
assert self.get_element(self.person_page_ele) is not None
Log.info("Arrive Personal Details page of id: %s" % select_data)
except Exception, e:
Log.error(e)
def decrypt(encryptCode: str, _private_key=private.api_key) -> Any:
"""私钥解密"""
try:
_secret_byte_obj = base64.b64decode(encryptCode)
cipher_pri_obj = PKCS1_v1_5.new(RSA.import_key(_private_key))
_byte_obj = cipher_pri_obj.decrypt(_secret_byte_obj,
Random.new().read)
plain_text = _byte_obj.decode("utf-8")
Log.info(f"RSA加密信息结果：{plain_text}")
return json.loads(plain_text)
except Exception as ex:
Log.error(f"解析RSA加密信息失败：{ex}")
return {}
def get_windows_img(self):
"""
save the screenshot
"""
file_path = "screenshots//"
rq = time.strftime('%Y%m%d%H%M', time.localtime(time.time()))
screen_name = file_path + rq + '.png'
try:
self.driver.get_screenshot_as_file(screen_name)
Log.info("Save screen shot to screenshots")
except NameError as e:
Log.error("Failed to take screenshot! %s" % e)
self.get_windows_img()
def get_element_attribute(self, keys, attkey):
"""
Get element attribute value
"""
try:
element = self.get_element(keys)
if element is None:
return None
else:
value = element.get_attribute(attkey)
return value
except BaseException, e:
Log.error(e)
def input_text(self, value, keys):
"""
Input text
"""
try:
element = self.get_element(keys)
if element is None:
return None
else:
element.clear() # added by Linda
element.send_keys(value)
except BaseException, e:
Log.error(e)
def get_element_text(self, keys):
"""
Get element text
"""
try:
element = self.get_element(keys)
if element is None:
raise Exception(
Log.error(
"Could not locate the element value {}".format(keys)))
else:
return element.text
except BaseException, e:
Log.error(e)
def set_combox_value(self, value, keys):
"""
Choose combox value
"""
try:
element = self.get_element(keys)
if element is None:
raise Exception(
Log.error(
"Could not locate the element value {}".format(keys)))
else:
Select(element).select_by_visible_text(value)
except NoSuchElementException:
Log.error("Could not locate the element value {}".format(value))
class RaidMonitor(object):
def __init__(self):
self.logger = Log("raid_mon", config=conf)
self.is_running = False
self.last_state = True
self.vps_mgr = VPSMgr()
self.hostname = socket.gethostname()
def start(self):
if self.is_running:
return
self.is_running = True
self.logger.info("started")
def stop(self):
if not self.is_running:
return
self.is_running = False
def send_alarm(self, msg):
rpc = self.vps_mgr.rpc_connect()
try:
rpc.alarm("%s: raid_mon: %s" % (self.hostname, msg))
finally:
rpc.close()
def check(self):
cmd = """MegaCli64 -pdlist -aall | grep -i 'firmware state:' | grep -P -v -i "online|Unconfigured\(good\)" """
try:
out, err = subprocess.Popen(cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE).communicate()
msg = out + err
if msg:
self.logger.error(msg)
if self.last_state:
self.last_state = False
self.send_alarm("error, %s" % (out))
self.logger.error("alarm sent")
else:
self.logger.info("ok")
if not self.last_state:
self.send_alarm("ok")
self.last_state = True
except Exception, e:
self.logger.exception(e)
def main():
bridge = args[0]
vif_name = args[1]
logger = Log("vps_mgr", config=conf)
try:
ovsops = OVSOps()
ofport = ovsops.find_ofport_by_name(vif_name)
if ofport < 0:
logger.error("vif %s ofport=%s, skip it" % (vif_name, ofport))
else:
ovsops.unset_mac_filter(bridge, ofport)
# it's strange that if you unset traffic first, might find ofport==-1
ovsops.unset_traffic_limit(vif_name)
logger.debug("unset %s" % vif_name)
return 0
except Exception, e:
logger.exception(e)
print >> sys.stderr, str(e)
return 0
def main():
bridge = args[0]
vif_name = args[1]
logger = Log("vps_mgr", config=conf)
vpsops = VPSOps(logger)
logger.debug("set %s" % vif_name)
try:
ovsops = OVSOps()
om = re.match(r"^\w+?(\d+)\w*?$", vif_name)
if not om:
print >> sys.stderr, "wrong vif format %s" % (vif_name)
return 1
vps_id = int(om.group(1))
xv = vpsops.load_vps_meta(vps_id)
vif = xv.vifs.get(vif_name)
if not vif:
logger.error("no vif %s in metadata of %s" % (vif_name, vps_id))
return 1
ofport = ovsops.find_ofport_by_name(vif_name)
if ofport < 0:
logger.error("vif %s ofport=%s, fix it by delete the port from bridge " % (vif_name, ofport))
ovsops.del_port_from_bridge(bridge, vif_name)
ovsops.add_port_to_bridge(bridge, vif_name)
ofport = ovsops.find_ofport_by_name(vif_name)
if ofport < 0:
logger.error("vif %s ofport=%s, impossible " % (vif_name, ofport))
if ofport >= 0:
ovsops.set_mac_filter(bridge, ofport, vif.ip_dict.keys())
ovsops.unset_traffic_limit(vif_name)
bandwidth = float(vif.bandwidth or 0)
ovsops.set_traffic_limit(vif_name, int(bandwidth * 1000))
print "set vif %s bandwidth %sm/s" % (vif_name, vif.bandwidth)
return 0
except Exception, e:
logger.exception(e)
print >> sys.stderr, str(e)
return 1
def _load(self):
# get routes
f = open('config/route.json')
r = json.load(f)
# get uri
path = Url.getUri()
# if url doesn't end with /, redirect to / ended url
if path.endswith('/') == False:
path = path + "/"
raise web.redirect(path, '301 ')
# check url in routes json
for key,value in r.items():
if self._regex(path, key):
# controller dynamic load
module_name = "controller.{}".format(value['controller'])
# uppercase first char
class_name = value['controller'].title()
#default method name
method_name = 'main'
if 'method' in value:
method_name = value['method']
# from path import module
try:
module = __import__(module_name, fromlist=[class_name])
except Exception as e:
Log.error(e)
raise Error('500')
# get class from module
try:
class_object = getattr(module, class_name)
except Exception as e:
return Log.error(e)
# instance module
try:
controller_instance = class_object()
except Exception as e:
return Log.error(e)
# exec method from class instance
try:
func = getattr(controller_instance, method_name)
except Exception as e:
return Log.error(e)
# method instance
try:
func_instance = func()
return func_instance
except Exception as e:
m = re.match("[0-9]{3}", str(e))
if m:
http_code = m.group(0)
if re.match("(4|5)", http_code):
Error(http_code)
# redirect to 404 page
raise Error('404')
class TransWarpClient (TransWarpBase):
def __init__(self):
TransWarpBase.__init__(self)
self.logger = Log("client", config=config)
self.engine.set_logger(self.logger)
self.sock5_addr = config.SOCK5_ADDR
self._sock5_users = 'SOCK5_USERS' in dir(
config) and config.SOCK5_USERS or {}
ip = self.sock5_addr[0]
arr = map(lambda x: chr(int(x)), ip.split("."))
self._sock5_server_id = struct.pack(
"!4cH", arr[0], arr[1], arr[2], arr[3], self.sock5_addr[1])
self.server_addr = config.SERVER_ADDR
self.sock5_sock = None
self.key = config.KEY
def start(self):
if self.is_running:
return
self.sock5_sock = self.engine.listen_addr(
self.sock5_addr, readable_cb=None, new_conn_cb=self._sock5_handshake, backlog=50)
self.is_running = True
def stop(self):
if not self.is_running:
return
self.engine.unlisten(self.sock5_sock)
self.is_running = False
def _send_sock5_unsupport(self, conn):
self.logger.error("peer %s not supported" % (str(conn.peer)))
buf = "%s%s\x00\x01%s" % (VER, "\x07", self._sock5_server_id)
def __write_ok(conn):
self.engine.close_conn(conn)
return
self.engine.write_unblock(conn, buf, __write_ok)
def _send_sock5_reply(self, client, err_no):
if err_no == 0:
status = "\x00"
elif err_no == errno.ENETUNREACH:
status = "\x03"
elif err_no == errno.EHOSTUNREACH:
status = "\x04"
elif err_no == errno.ECONNREFUSED:
status = "\x05"
else:
status = "\x01" # general error
buf = "%s%s\x00\x01%s" % (VER, status, self._sock5_server_id)
def __write_ok(cli_conn, *args):
if err_no == 0:
self.logger.info(
"client %s: sent sock5 response" % (client.client_id))
client.cli_state = proto.ClientState.CONNECTED
self._check_client_state(client)
else:
self.logger.info(
"client %s: sent sock5 err response and close" % (client.client_id))
self.close_client(client)
return
self.engine.write_unblock(
client.cli_conn, buf, __write_ok, self._on_err, cb_args=(client,))
def _on_client_readable(self, cli_conn, client):
# print "client %s client readable" % (client.client_id)
self.stream_to_fix(cli_conn, client.r_conn, client)
def _on_remote_readable(self, r_conn, client):
# print "client %s remote readable" % (client.client_id)
self.fix_to_stream(r_conn, client.cli_conn, client)
def _on_server_connected(self, sock, client):
self.logger.info("client %s connected to server" % (client.client_id))
r_conn = Connection(sock)
_hash = proto.myhash(client.seed, self.key)
auth_data = proto.AuthData(
client.seed, _hash, self.key, client.r_host, client.r_port)
buf = auth_data.serialize()
buf = proto.pack_head(len(buf)) + buf
client.r_conn = r_conn
def __on_remote_respond(r_conn, *args):
resp = None
try:
buf = client.crypter_r.decrypt(r_conn.get_readbuf())
resp = proto.ServerResponse.deserialize(buf)
if resp.err_no:
self.logger.error("client %s: %s %s" %
(client.client_id, resp.err_no, resp.message))
self.close_client(client)
else:
self.logger.info(
"client %s server response" % (client.client_id))
client.r_state = proto.ClientState.CONNECTED
self._check_client_state(client)
except Exception, e:
self.logger.exception(
"client %s: server response error %s" % (client.client_id, str(e)))
self.close_client(client)
return
def __on_read_head(r_conn, *args):
data_len = 0
try:
data_len = proto.unpack_head(r_conn.get_readbuf())
except Exception, e:
self.logger.error(
"client %s remote head invalid" % (client.client_id))
self.close_client(client)
return
if data_len > 0:
self.engine.read_unblock(
r_conn, data_len, __on_remote_respond, self._on_err, cb_args=(client, ))
return
self.logger.error("zero len head")
self.close_client(client)
return
class ICMPMonitor (object):
def __init__(self):
self.is_running = False
self.linkage_dict = dict()
self.logger = Log("icmp_mon", config=config)
self.alarm_q = JobQueue(self.logger)
self.emailalarm = EmailAlarm(Log("alarm", config=config))
self.logger_links = Log("links", config=config)
if 'log_length_per_link' in dir(config):
self.log_length_per_link = config.log_length_per_link
else:
self.log_length_per_link = 128
if 'links' not in dir(config):
self.logger.error("no 'links' in config")
return
g_alarm_levels = None
g_recover = None
if 'alarm_levels' in dir(config):
g_alarm_levels = self._parse_alarm_levels(config.alarm_levels)
if 'recover' in dir(config):
g_recover = int(config.recover)
links = config.links
if isinstance(links, dict):
for ip, v in links.iteritems():
if not isinstance(v, dict):
v = dict()
ttl = v.get('ttl')
if ttl >= 0:
pass
else:
ttl = 0
alarm_levels = v.get('alarm_levels')
if not alarm_levels and g_alarm_levels:
alarm_levels = g_alarm_levels
elif alarm_levels:
alarm_levels = self._parse_alarm_levels(alarm_levels)
if not alarm_levels:
continue
else:
self.logger.error(
"config: %s, missing alarm_levels value" % (ip))
continue
recover = v.get('recover')
if recover:
recover = int(recover)
elif not recover and g_recover:
recover = g_recover
else:
self.logger.error(
"config: %s, missing recover value" % (ip))
continue
self.linkage_dict[ip] = Linkage(ip, alarm_levels, recover)
self.logger.info("%d link loaded from config" %
(len(self.linkage_dict.keys())))
def _parse_alarm_levels(self, alarm_levels, ip=""):
if not isinstance(alarm_levels, (tuple, list)):
self.logger.error("config: %s, alarm_levels is not a list" % (ip))
return
_alarm_levels = filter(lambda x: isinstance(x, int), alarm_levels)
if len(_alarm_levels) != len(alarm_levels):
self.logger.error(
"config: %s, elements in alarm_levels must be integers" % (ip))
return
return _alarm_levels
def start(self):
if self.is_running:
return
self.is_running = True
self.alarm_q.start_worker(1)
self.logger.info("started")
def stop(self):
if not self.is_running:
return
self.is_running = False
self.alarm_q.stop()
self.logger.info("stopped")
def _alarm_enqueue(self, link):
t = "%Y-%m-%d %H:%M:%S"
ts = "[%s]" % (time.strftime(t, time.localtime()))
job = AlarmJob(
self.emailalarm, ts + link.alarm_text(), link.details())
self.alarm_q.put_job(job)
def loop(self):
ips = self.linkage_dict.keys()
fping = FPing(ips)
while self.is_running:
start_time = time.time()
recv_dict, error_dict = fping.ping(1)
for ip, rtt in recv_dict.iteritems():
link = self.linkage_dict[ip]
res = link.new_state(True, rtt)
if res:
self._alarm_enqueue(link)
print ip, "ok", rtt
if len(link.bitmap) == self.log_length_per_link:
self.logger_links.info(link.details())
link.reset_bitmap()
for ip, err in error_dict.iteritems():
link = self.linkage_dict[ip]
res = link.new_state(False, 0)
if res is False:
self._alarm_enqueue(link)
print ip, "err", link.bitmap
if len(link.bitmap) == self.log_length_per_link:
self.logger_links.info(link.details())
link.reset_bitmap()
end_time = time.time()
if end_time < start_time + 1:
time.sleep(1 - end_time + start_time)
