def sendjson(self, method, urlpath, obj=None):
"""Send json to the OpenDaylight controller."""
headers = {'Content-Type': 'application/json'}
data = jsonutils.dumps(obj, indent=2) if obj else None
url = '/'.join([self.url, urlpath])
LOG.debug("Sending METHOD (%(method)s) URL (%(url)s) JSON (%(obj)s)" %
{'method': method, 'url': url, 'obj': obj})
r = requests.request(method, url=url,
headers=headers, data=data,
auth=self.auth, timeout=self.timeout)
try:
r.raise_for_status()
except Exception as ex:
LOG.error("Error Sending METHOD (%(method)s) URL (%(url)s)"
"JSON (%(obj)s) return: %(r)s ex: %(ex)s rtext: "
"%(rtext)s" %
{'method': method, 'url': url, 'obj': obj, 'r': r,
'ex': ex, 'rtext': r.text})
import pdb;pdb.set_trace()
return r
try:
return json.loads(r.content)
except Exception:
LOG.debug("%s" % r)
return
def delete(self, obj_typ, id=None, obj=None):
if not (id or obj):
LOG.error('Give either net_id or net_obj')
if obj:
id = obj.get('id')
return self.sendjson('delete', '%(obj_typ)s/%(id)s' %
{'obj_typ': obj_typ,
'id': id})
def catch_error(*args, **kwargs):
try:
res = func(*args, **kwargs)
except Exception as e:
LOG.error(traceback.format_exc())
# print traceback.format_exc()
return None
return res
def main():
try:
app = Application()
app.listen(address=options.address,
port=options.port,
max_body_size=TORNADO_MAX_BODY_SIZE)
LOG.info('Sever Listen {port}...'.format(port=options.port))
tornado.ioloop.IOLoop.instance().start()
except:
LOG.error(traceback.format_exc())
def run():
try:
all_test = AllTest()
all_test.runnerPool()
except Exception as e:
LOG.error("运行程序失败，原因：%s" % e)
finally:
"""关闭Appium服务"""
appium_server = AppiumServer(all_test.l_devices)
appium_server.stop_server()
sys.exit()
def get_conn():
try:
connection_dict = url.make_url(options.sql_conn)
conn = MySQLdb.connect(host=connection_dict.host,
user=connection_dict.username,
passwd=connection_dict.password,
db=connection_dict.database)
except Exception as e:
LOG.error("get mysql connection: %s" % e)
raise e
return conn
def sync_request(url,
method,
body=None,
headers=None,
token=None,
response_key=None):
"""
wrap async request
:param url: request url
:param token: OpenStack request session: Session
:param body: the dict of request body
:param headers: the dict of request headers
:param method: request method: GET\POST\DELETE\PUT
:param response_key:
:return: the dict of response body
"""
try:
hdr = __gen_header(method=method, token=token)
if headers:
hdr = hdr.copy()
hdr.update(hdr, **headers)
if body:
str_body = json.dumps(body)
else:
str_body = None
if method == METHOD_GET:
resp = requests.get(url=url, headers=hdr)
elif method == METHOD_POST:
resp = requests.post(url=url, data=str_body, headers=hdr)
elif method == METHOD_PUT:
resp = requests.put(url=url, data=str_body, headers=hdr)
elif method == METHOD_DELETE:
resp = requests.delete(url=url, headers=hdr)
elif method == METHOD_PATCH:
resp = requests.patch(url=url, data=str_body, headers=hdr)
else:
raise exception.UnSupportMethodError(method=method)
except Exception as e:
LOG.error("sync_request failed: %s" % e)
raise e
else:
if resp.status_code in RESPONSE_OKS:
rep = resp.json()
if response_key and response_key in rep:
rep = rep[response_key]
elif resp.status_code == RESPONSE_NO_CONTENT:
rep = None
else:
LOG.error("sync_request failed: %s" % resp.json())
rep = None
return rep
def delete_server(token, server_id, handle_obj):
try:
url = "/servers/%s" % server_id
ret_ok = request.sync_ops_request(token=token,
service_type=request.TYPE_COMPUTE,
url=url,
method=request.METHOD_DELETE)
except Exception as e:
LOG.error("delete server error: %s" % e)
return None
else:
return ret_ok
def catch_error(*args, **kwargs):
try:
res = func(*args, **kwargs)
except Exception as e:
LOG.error(traceback.format_exc())
LOG.info("================content start================")
_content = kwargs.get("content")
_content = _content if _content else args[0]
print _content
LOG.info("================content end================")
return None
return res
def encrypt(string, salt='', encrypt_way='MD5'):
u"""根据输入的string与加密盐，按照encrypt方式进行加密，并返回加密后的字符串"""
string += salt
if encrypt_way.upper() == 'MD5':
hash_string = hashlib.md5()
elif encrypt_way.upper() == 'SHA1':
hash_string = hashlib.sha1()
else:
LOG.error(EncryptError('请输入正确的加密方式，目前仅支持 MD5 或 SHA1'))
return False
hash_string.update(string.encode())
return hash_string.hexdigest()
def catch_error(*args, **kwargs):
try:
res = func(*args, **kwargs)
except Exception as e:
LOG.error(traceback.format_exc())
LOG.info("================content start================")
_content = kwargs.get("content")
_content = _content if _content else args[0]
print _content
LOG.info("================content end================")
return None
return res
def create_server(token, server_info, handle_obj):
try:
ret_ok = request.sync_ops_request(token=token,
service_type=request.TYPE_COMPUTE,
url="/servers",
body=server_info,
method=request.METHOD_POST,
response_key="server")
except Exception as e:
LOG.error("create server error: %s" % e)
return None
else:
return ret_ok
def __get_server(token, server_id):
try:
url = "/servers/%s" % server_id
ret_ok = request.sync_ops_request(token=token,
service_type=request.TYPE_COMPUTE,
url=url,
method=request.METHOD_GET,
response_key="server")
except Exception as e:
LOG.error("get server error: %s" % e)
return None
else:
if ret_ok and ret_ok.get("metadata"):
return ret_ok.get("metadata")
else:
return None
def __init__(self, message=None, **kwargs):
self.kwargs = kwargs
if 'code' not in self.kwargs:
try:
self.kwargs['code'] = self.code
except AttributeError:
pass
if not message:
try:
message = self.message % kwargs
except Exception as e:
message = self.message
LOG.error(e)
super(PrePoolException, self).__init__(message)
def __sync_get_token(tenant=None, username=None, password=None):
"""
get the token of specific tenant, default tenant is admin, user is admin.
:param tenant: tenant id, default None
:return: the session of specific tenant
"""
try:
login_body = __gen_auth_body(tenant=tenant,
username=username,
password=password)
resp = sync_request(url=options.auth_url,
body=login_body,
method=METHOD_POST,
response_key="access")
if resp:
session = __get_session(resp)
else:
raise exception.OpenStackError
except Exception as e:
LOG.error(e)
raise e
return session
def get_server(token, server_id, handle_obj):
try:
loop_counter = 0
while 1:
loop_counter += 1
server_metadata = __get_server(token=token, server_id=server_id)
if not server_metadata:
continue
server_ip = server_metadata.get("host_ip")
server_port = int(server_metadata.get("port"))
ping_ok = ping_vm_port(server_ip=server_ip,
server_port=server_port)
if ping_ok:
LOG.info(
"server %s 's ip: %s and port: %s network be reasonable." %
(server_id, server_ip, server_port))
break
eventlet.sleep(1)
if loop_counter >= options.request_timeout_seconds:
raise exception.RequestTimeOut()
except Exception as e:
LOG.error("get server status ok error %s" % e)