def _http_request(method, url, headers=None, data=None):
try:
if method == "GET":
resp = requests.get(url=url, headers=headers, params=data)
elif method == "HEAD":
resp = requests.head(url=url, headers=headers)
elif method == "POST":
resp = requests.post(url=url, headers=headers, json=data)
elif method == "DELETE":
resp = requests.delete(url=url, headers=headers, json=data)
elif method == "PUT":
resp = requests.put(url=url, headers=headers, json=data)
else:
return False, None
except requests.exceptions.RequestException:
logger.exception("login http request error! type: %s, url: %s, data: %s" % (method, url, str(data)))
return False, None
else:
if resp.status_code != 200:
content = resp.content[:100] if resp.content else ''
logger.error("login http request error! type: %s, url: %s, data: %s, response_status_code: %s, response_content: %s" # noqa
% (method, url, str(data), resp.status_code, content))
return False, None
return True, resp.json()
def get_path_for_chunk(hsh):
if hsh not in my_chunks:
if os.path.exists(store_name + hsh):
return store_name + hsh
logger.error('chunk {} does not exists'.format(hsh))
return None
return my_chunks[hsh]
def get(self,tablename):
try:
session = Session()
M = make_table_model(tablename.encode('utf-8'))
#filter_args = [ getattr(M,k)==v[0] for k,v in self.request.arguments.items()]
_params = {}
[_params.update({k: v[0]}) for k, v in self.request.arguments.items()]
logger.info(tablename+str(_params))
filter_args = utils.get_filter_args(M, _params)
if filter_args:
models = session.query(M).filter(*filter_args).order_by(desc('id')).limit(100)
else:
models = session.query(M).order_by(desc('id')).limit(100)
logger.debug(models)
models = [ [ getattr(model,c.name) for c in M.__table__._columns] for model in models]
clms = map(lambda x:x.name, M.__table__._columns)
# hide the primary_key
result = map(lambda x: dict(zip(clms[1:], x[1:])), models)
for item in result:
for k in item:
if type(item[k])==datetime:
item[k] = item[k].strftime("%Y-%m-%d %H:%M:%S")
elif type(item[k])==unicode:
item[k] = item[k].strip()
self.write(json.dumps(result))
except BaseException, e:
self.write(json.dumps({'msg':'Request Error'}))
logger.error(traceback.format_exc(e))
def parse(cmd, size, args, transp):
global last_transport
last_transport = transp
cmds = {b'JOIN': JOIN,
b'FADD': FADD,
b'FPDT': FUPT,
b'FDEL': FDEL}
if cmd not in cmds:
logger.error('unknown command {}'.format(cmd))
return
client = None
if transp in shared.climanager.transports:
client = shared.climanager.transports[transp]
if client is None and cmd != b'JOIN':
logger.error("""no client has been found for this connection and """
"""command {}. Refusing to continue""".format(cmd))
# TODO: use size
cmds[cmd](client, args)
def is_bk_token_valid(self, request):
"""验证用户登录态."""
bk_token = request.COOKIES.get(settings.BK_COOKIE_NAME, None)
if not bk_token:
return False, None
ret, data = self.verify_bk_login(bk_token)
# bk_token 无效
if not ret:
return False, None
# 检查用户是否存在用户表中
username = data.get('username', '')
user_model = get_user_model()
try:
user = user_model._default_manager.get_by_natural_key(username)
except user_model.DoesNotExist:
user = user_model.objects.create_user(username)
finally:
try:
ret, data = self.get_bk_user_info(bk_token)
# 若获取用户信息失败，则用户可登录，但用户其他信息为空
user.chname = data.get('chname', '')
user.company = data.get('company', '')
user.qq = data.get('qq', '')
user.phone = data.get('phone', '')
user.email = data.get('email', '')
# 用户权限更新,保持与平台同步
role = data.get('role', '')
is_admin = True if role == '1' else False
user.is_superuser = is_admin
user.is_staff = is_admin
user.save()
except Exception as e:
logger.error(u"获取记录用户信息失败：%s" % e)
return True, user
def __init__():
try:
global conn
conn = psycopg2.connect("dbname=storeit user=server host=localhost")
except Exception as e:
print(e)
logger.error('could not connect to db')
def get_time():
"""
celery 周期任务示例
run_every=crontab(minute='*/5', hour='*', day_of_week="*")：每 5 分钟执行一次任务
periodic_task：程序运行时自动触发周期任务
"""
execute_task()
now = datetime.datetime.now()
logger.error(u"celery 周期任务调用成功，当前时间：{}".format(now))
def get_bk_user_info(self, bk_token):
"""请求平台接口获取用户信息"""
param = {'bk_token': bk_token}
result, resp = http_get(self.BK_GET_USER_INFO_URL, param)
resp = resp if result and resp else {}
ret = resp.get('result', False) if result and resp else False
# 获取用户信息失败
if not ret:
logger.error(u"请求平台接口获取用户信息失败：%s" % resp.get('message', ''))
return False, {}
return True, resp.get('data', {})
def send_cmd(self, msg):
if self.transport is None:
logger.error('client has no transport registered')
return
if type(msg) is str:
msg = msg.encode()
final_cmd = msg[:5] + bytes(str(len(msg) - 5) + ' ', 'ascii') + msg[5:]
logger.debug('to {}: {}'.format(self.username, final_cmd.decode()))
self.transport.write(final_cmd)
def func_check(self, func_code):
"""
@summary: 检查改功能是否开放
@param func_code: 功能ID
@return: (True/False, 'message')
"""
try:
enabled = self.get(func_code=func_code).enabled
return (True, int(enabled))
except Exception, e:
logger.error(u"检查改功能是否开放发生异常，错误信息：%s" % e)
return (False, 0)
def send_CSND(from_cli, to_cli, send: int, chk: str):
if to_cli.transport is None:
logger.error("send_CSND: client has no transport")
return
addr = to_cli.transport.get_extra_info('peername')
if addr is None:
logger.error('could not get ip for user {}'.format(to_cli.username))
addr_and_port = addr[0] + ':' + to_cli.port
from_cli.send_cmd('CSND {} {} {}'
.format(send, chk, addr_and_port))
def texteditor_escape(str_escape):
"""
富文本处理
@param str_escape: 要检测的字符串
"""
try:
parser = XssHtml()
parser.feed(str_escape)
parser.close()
return parser.get_html()
except Exception, e:
logger.error(u"js脚本注入检测发生异常，错误信息：%s" % e)
return str_escape
def find_tree_rec(path, tr):
path_sep = path.split('/', 1)
if len(path_sep) == 2:
return tr['files'], path_sep[1]
elif path_sep[0] not in tr['files']:
logger.error('error {} is invalid'.format(subtree['path']))
return None, None
else:
# TODO: handle deletion. Maybe if the thing exists and
# has same metadata delete it
return find_tree_rec(path_sep[1], tr['files'][path_sep[0]])
def save_records(records):
session = Session()
for r in records:
try:
r = eval(r)
tablename = r['tablename']
data = r['data']
M = make_table_model(tablename.encode('utf-8'))
m = M()
for k,v in data.items():
setattr(m,k,v)
session.add(m)
logger.debug('%s save %s'%(tablename,str(m)))
except Exception,e:
logger.error(traceback.format_exc(e))
def getColumn(self, factor):
"""
根据数据表名和列名获取列对象
"""
tablename, columnname = map(lambda x: factor.get(x), \
Protocol.Table, Protocol.Attr)
table = self.getTable(tablename)
if not table:
return None
if not table.c.has_key(columnname):
msg = u'can''t recongnize column name of {0}'.format(c_str)
logger.error(msg)
return None
column = table.c.get(columnname)
return column
def execute_task():
"""
执行 celery 异步任务
调用celery任务方法:
task.delay(arg1, arg2, kwarg1='x', kwarg2='y')
task.apply_async(args=[arg1, arg2], kwargs={'kwarg1': 'x', 'kwarg2': 'y'})
delay(): 简便方法，类似调用普通函数
apply_async(): 设置celery的额外执行选项时必须使用该方法，如定时（eta）等
详见 ：http://celery.readthedocs.org/en/latest/userguide/calling.html
"""
now = datetime.datetime.now()
logger.error(u"celery 定时任务启动，将在60s后执行，当前时间：{}".format(now))
# 调用定时任务
async_task.apply_async(args=[now.hour, now.minute], eta=now + datetime.timedelta(seconds=60))
def login(client):
json_tree = tree.usertree
my_chks = list(chunk.my_chunks.keys())
my_store = [] # TODO: later read the content of .store
hashes = 'None' if len(my_chks) == 0 else ':'.join(my_chks + my_store)
try:
network.send_cmd('JOIN {} {} {} {}'
.format(client.username, client.port,
hashes, json.dumps(json_tree)))
except Exception as e:
logger.error('2: {} was raised'.format(log.nomore(e)))
for l in traceback.format_tb(e.__traceback__):
logger.debug(l)
raise e
def get_context_processors_content(request):
"""
return the context_processors dict context
"""
context = Context()
try:
from django.utils.module_loading import import_string
from django.template.context import _builtin_context_processors
context_processors = _builtin_context_processors
for i in settings.TEMPLATES:
context_processors += tuple(i.get('OPTIONS', {}).get('context_processors', []))
cp_func_list = tuple(import_string(path) for path in context_processors)
for processors in cp_func_list:
context.update(processors(request))
except Exception, e:
logger.error(u"Mako: get_context_processors_content error info:%s" % e)
context = Context()
def get_echart(self, shape=u'bar'):
if 'table' == shape:
return Table()
elif 'bar' == shape:
return Bar()
elif 's_bar' == shape:
return Bar()
elif 'placehold_bar' == shape:
return Bar()
elif 'line' == shape:
return Line()
elif 's_line' == shape:
return Line()
elif 'area' == shape:
return Area()
elif 's_area' == shape:
return Area()
elif 'scatter' == shape:
return Scatter()
elif 'pie' == shape:
return Pie()
elif 'radar' == shape:
return Radar()
elif 'map' == shape:
return ChinaMap()
elif 'world_map' == shape:
return WorldMap()
elif 'gis' == shape:
return Gis()
else:
logger.error('shape = {}'.format(shape))
raise Exception(u'Unknown pictrue shape')
def connection_made(self, transp):
NetworkClient.connection_made(self, transp)
global server_transport
logger.info("connected to master server")
server_transport = transp
try:
protocol.login(self)
except Exception as e:
logger.error(e)
logger.error('{} was raised'.format(log.nomore(e)))
for l in traceback.format_tb(e.__traceback__):
logger.debug(l)
raise e
def run_many():
start_time = time.time()
runner = Runner()
num_runs = 10
for _ in range(num_runs):
node_list = LightningNode.objects.all()
runner.reset_timing_stats()
exceptions_per_node = {}
total_enabled_nodes = 0
for node in node_list:
logger.debug("--------------------- {} id={} ----------------------------".format(node.node_name, node.id))
if not node.enabled:
logger.debug("Node {} disabled, skipping...".format(node.node_name))
continue
else:
total_enabled_nodes += 1
try:
one_node_helper(runner, node)
except Exception as e:
logger.warning("Exception in one of the nodes in run_many: {}".format(e))
exceptions_per_node[node.node_name] = e
sleep(BETWEEN_NODES_DELAY)
if total_enabled_nodes == 0:
logger.error("No nodes enabled")
elif len(exceptions_per_node) >= total_enabled_nodes:
logger.error("All nodes has exceptions, e.g. {}".format(exceptions_per_node[node_list[0].node_name]))
runner.log_timing_stats()
runner.log_cumulative_timing_stats()
logger.info("\n")
processing_wall_time = time.time() - start_time
logger.info("Finished {} runs in wall-time of {:.3f} seconds".format(num_runs, processing_wall_time))
logger.info("\n\n\n\n\n")
def save_task(request):
"""
创建/编辑周期性任务 并 运行
"""
periodic_task_id = request.POST.get('periodic_task_id', '0')
params = request.POST.get('params', {})
try:
params = json.loads(params)
add_param = params.get('add_task', {})
except:
msg = u"参数解析出错"
logger.error(msg)
result = {'result': False, 'message': msg}
return render_json(result)
task_args1 = add_param.get('task_args1', '0')
task_args2 = add_param.get('task_args2', '0')
# 任务参数
try:
task_args1 = int(task_args1)
task_args2 = int(task_args2)
task_args_list = [task_args1, task_args2]
task_args = json.dumps(task_args_list)
except:
task_args = '[0,0]'
logger.error(u"解析任务参数出错")
# 周期参数
minute = add_param.get('minute', '*')
hour = add_param.get('hour', '*')
day_of_week = add_param.get('day_of_week', '*')
day_of_month = add_param.get('day_of_month', '*')
month_of_year = add_param.get('month_of_year', '*')
# 创建周期任务时，任务名必须唯一
now = int(time.time())
task_name = "%s_%s" % (TASK, now)
if periodic_task_id == '0':
# 创建任务并运行
res, msg = add_peroid_task(TASK, task_name, minute, hour,
day_of_week, day_of_month,
month_of_year, task_args)
else:
# 修改任务
res, msg = edit_peroid_task_by_id(periodic_task_id, minute, hour,
day_of_week, day_of_month,
month_of_year, task_args)
return render_json({'result': res, 'message': msg})
def card_sn_in_blacklist(self):
"""
黑名单查询
:return:
"""
issuer_info = self.command_recv_set.info_b4['IssuerInfo']
card_net = int(issuer_info[20:24]) # 需要转换为整数
card_sn = issuer_info[24:40]
issuer_identifier = self.command_recv_set.info_b2['IssuerIdentifier']
card_sn_in_blacklist_flag = ThirdEtcApi.exists_in_blacklist(
issuer_identifier=issuer_identifier,
card_net=card_net,
card_id=card_sn)
error_msg = None
if card_sn_in_blacklist_flag:
error_msg = 'card_id:%s in blacklist' % card_sn
logger.error(error_msg)
return card_sn_in_blacklist_flag, error_msg
def search_host_by_ip(request):
try:
client = get_client_by_user(request.user.username)
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
"ip" : {"flag": "bk_host_innerip|bk_host_outerip","exact": 1,"data": ['192.168.165.51']},
"condition": []
}
result = client.cc.search_host(kwargs)
d={}
if result["result"]:
d = {}
return render_json({"result": True, "data": d})
except Exception as e:
logger.error(e)
def get_custom_monitor_num(request, cc_biz_id):
"""获取自定义监控数量
:param request:
:param cc_biz_id:
:return:
"""
try:
# 获取自定义监控数量
monitor_num = len(
Monitor.objects.filter(biz_id=cc_biz_id,
monitor_type='custom',
is_enabled=True))
res = {'result': True, 'message': '', 'data': monitor_num}
except Exception as e:
logger.error(traceback.format_exc())
res = {'result': False, 'message': u"查询接口失败：%s" % e, 'data': []}
return render_json(res)
def get_model(self, memo):
post_preview = PostPreview()
if "parent_post_id" in memo:
parent_post_id = memo["parent_post_id"]
# Find the parent.
try:
parent = Post.objects.get(pk=parent_post_id)
except ObjectDoesNotExist, exc:
logger.error("The post does not exist. Perhaps it was deleted request (Request: %s)", request)
logger.exception(e)
raise
post_preview.parent_post_id = parent_post_id
post_preview.title = parent.title
post_preview.tag_val = parent.tag_val
post_preview.tag_value = html_util.split_tags(parent.tag_val)
def post_preview_body(context, post_preview):
"Renders the post preview body"
if type(post_preview) != PostPreview:
logger.error("post_preview is {}".format(post_preview))
memo = post_preview.serialize_memo()
return dict(post=post_preview,
edit_url=post_preview.get_edit_url(memo),
publish_url=post_preview.get_publish_url(memo),
preview_url=post_preview.get_preview_url(post_preview.memo),
request=context['request'],
payment_amount=settings.POST_PAYMENT_AMOUNT,
memo_json=json.dumps(json_util.deserialize_memo(memo),
sort_keys=True),
form=context["form"],
user=context['user'],
date=post_preview.date)
def parse_data(data):
try:
for server in data:
get_log_list = server['log_content'].split('@@@@@@@@@@')
load_data = get_log_list[0].split(':')[1]
disk_data = get_log_list[1].split(':')[1]
cpu_data = get_log_list[2].split(':')[1]
host = Host.objects.get(host_ip=server['ip'])
tm = str(datetime.datetime.now()).split('.')[0]
load = load_data.split()[1]
Load.objects.create(created_time=tm, load_info=load, host=host)
host.men = json.dumps(make_men_data(disk_data))
host.disk = json.dumps(make_disk_data(disk_data))
host.save()
except Exception as e:
logger.error(e)
def query_userinfo(self, request, openid, openkey):
"""
获取用户信息包括用户昵称和头像
return: {'nick_name': nick_name, 'avatar_url': avatar_url}
"""
userinfo = {'openid': openid, 'openkey': openkey}
client = get_client_by_request(request)
resp = client.oidb.get_user_info({'openid': openid, 'openkey': openkey})
result = resp.get('result', False)
if not result:
message = resp.get('message', '')
logger.error(u"调用组件 get_user_info 出错，openid:%s, message:%s, resp：%s" % (openid, message, resp))
return False
data = resp.get('data', {})
userinfo['nick_name'] = data.get('nick_name', '')
userinfo['avatar_url'] = data.get('avatar_url', '')
return userinfo
def search_buseness(request):
try:
client = get_client_by_user(request.user.username)
param = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******'
}
result = client.cc.search_business(param)
user_business_list = []
if result["result"]:
user_business_list = [
{"id": i["bk_biz_id"], "text": i["bk_biz_name"]} for i in result["data"]["info"]
]
return render_json({"result": True, "data": user_business_list})
except Exception as e:
logger.error(e)
def get_token(appid, appsec):
"""
通过appid和appsec来获取access_token
:param appid: 公众号的appid
:param appsec: 公众号的appsecret
:return: string
"""
url = 'https://api.weixin.qq.com/cgi-bin/token'
payload = {
'grant_type': 'client_credential',
'appid': appid,
'secret': appsec,
}
resp = requests.get(url, params=payload, timeout=1, verify=True)
if 'access_token' not in resp.json():
logger.error('GetToken ERROR: {}'.format(resp.json()))
return ''
return resp.json()['access_token']
def poll_task(request):
"""
@summary: 轮询定时任务
"""
try:
record_id = request.GET.get('record_id', '')
record = Timing_task_record.objects.get(id=record_id)
if record.is_excuted == 0:
result = {'result': 2, 'message': u"未执行定时任务"}
else:
result = {
'result': 1,
'title': record.title,
'content': record.content
}
except Exception, e:
logger.error(u"轮询定时任务状态出错：%s" % e)
result = {'result': 0, 'message': u"轮询定时任务状态出错"}
def save_data(self, data):
"""
保存执行结果数据
"""
try:
CapacityData.objects.create(ip=data[6],
filesystem=data[0],
size=data[1],
used=data[2],
avail=data[3],
use=data[4],
mounted=data[5],
createtime=datetime.now())
result = {'result': True, 'message': u"保存成功"}
except Exception as e:
logger.error(u"save_data %s" % e)
result = {'result': False, 'message': u"保存失败, %s" % e}
return result
def save_data(self, data):
"""
保存执行结果数据
"""
try:
CpuData.objects.create(
ip=data['ip'],
checkdate=data['checkdate'],
Mem=data['Mem'],
Disk=data['Disk'],
Cpu=data['Cpu'],
creattime=datetime.now(),
)
result = {'result': True, 'message': u"保存成功"}
except Exception, e:
logger.error(u"save_data %s" % e)
result = {'result': False, 'message': u"保存失败, %s" % e}
def process_view(self, request, view, args, kwargs):
try:
# 判断豁免权
if getattr(view, 'escape_exempt', False):
return None
escapeType = None
if getattr(view, 'escape_script', False):
escapeType = "script"
elif getattr(view, 'escape_url', False):
escapeType = "url"
# get参数转换
request.GET = self.__escape_data(request.path, request.GET, escapeType)
# post参数转换
request.POST = self.__escape_data(request.path, request.POST, escapeType)
except Exception as e:
logger.error(u"CheckXssMiddleware 转换失败！%s" % e)
return None
def search_inst(request):
try:
client = get_client_by_user(request.user.username)
param = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": '******',
'bk_obj_id': 'mssql',
'condition': {},
'bk_supplier_account': '0'
}
result = client.cc.search_inst(param)
inst_data = {}
if result['result']:
inst_data = {'inst_id': result['data']['info'][0]['bk_inst_id']}
return render_json({'result': True, 'data': inst_data})
except Exception as e:
logger.error(e)
def __check_escape_type(self, path, param, check_path_list, escape_type):
"""
判断过滤类型
@param path: 请求Path
@param param: 请求参数
@param check_path_list: 指定类型Path列表
@param escape_type: 判断过滤类型
@param result_type: 结果类型
"""
try:
result_type = 'html'
for script_path, script_v in check_path_list.items():
is_path = re.match(r'^%s' % script_path, path)
if is_path and param in script_v:
result_type = escape_type
break
except Exception, e:
logger.error(u"CheckXssMiddleware 特殊path处理失败！错误信息%s" % e)
def search_business(user='******'):
URL = BK_PAAS_HOST + "/api/c/compapi/v2/cc/search_business/"
kwargs = {
"bk_app_code": APP_ID,
"bk_app_secret": APP_TOKEN,
"bk_username": user
}
res_json = requests.post(url=URL, json=kwargs, verify=False)
res = json.loads(res_json.content)
if res['result']:
ret = [{
'bk_biz_id': i['bk_biz_id'],
'bk_biz_name': i['bk_biz_name']
} for i in res['data']['info']]
return ret
else:
logger.error(u'获取业务失败' + str(res))
return []
def get_business(req):
bis_id = req.POST.get("bis_id")
if bis_id == None or bis_id == "":
return render_json({'code': False, 'msg': u"必须传递参数bis_id且值不为空"})
try:
business = BkingBusiness.objects.get(bis_id=bis_id)
return render_json({
'code': True,
'msg': u"查询数据成功",
'list': convert_obj_to_dicts(business)
})
except Exception, e:
logger.error('get object for BkingBusiness is error:{}'.format(
repr(e)))
return render_json({
'code': False,
'msg': u"数据查询失败:{}".format(repr(e))
})
def add_sys(request):
try:
username = request.user.username
request_data = json.loads(request.body)
data = {
"id": "1",
"sys_name": "test1",
"sys_code": "te1",
"owners": "dd",
"is_control": "否",
"department": "dd",
"comment": "dja",
"first_owner": "lhf"
}
return render_json({"result": True, "data": data})
except Exception as e:
logger.error(e)
return render_json({"result": False, "msg": [u"查询系统信息失败!!"]})
def __check_escape_type(self, path, param, check_path_list, escape_type):
"""
判断过滤类型
@param path: 请求Path
@param param: 请求参数
@param check_path_list: 指定类型Path列表
@param escape_type: 判断过滤类型
@param result_type: 结果类型
"""
try:
result_type = 'html'
for script_path, script_v in check_path_list.items():
is_path = re.match(r'^%s' % script_path, path)
if is_path and param in script_v:
result_type = escape_type
break
except Exception, e:
logger.error(u"CheckXssMiddleware 特殊path处理失败！错误信息%s" % e)
def payaward(node_id, award_id, invoice, sig):
response = call_endpoint('ln/payaward',
args={
"node_id": node_id,
"award_id": award_id,
"invoice": invoice,
"sig": sig
})
if response.status_code != 200:
error_msg = (
"Got API error when calling payaward, http_status={},node_id={},award_id={},invoice={},sig={}"
.format(response.status_code, node_id, award_id, invoice, sig))
logger.error(error_msg)
raise LNUtilError(error_msg)
response_parsed = response.json()[0]
return response_parsed
def check_payment(memo, node_id):
response = call_endpoint('ln/check',
args={
"memo": memo,
"node_id": node_id
})
if response.status_code != 200:
error_msg = (
"Got API error when looking up checkpoint, http_status={},node={},memo={}"
.format(response.status_code, node_id, memo))
logger.error(error_msg)
raise LNUtilError(error_msg)
check_expected_key(response, "checkpoint_value", is_list=True)
response_parsed = response.json()[0]
return response_parsed
def save_data(self, data):
"""
保存执行结果数据
"""
try:
CapacityData3.objects.create(
ip=data[0],
mem_disk_cpu=data[1],
exec_time=data[2],
set=data[3],
module=data[4],
instname=data[5],
osname=data[6],
)
result = {'result': True, 'message': u"保存成功"}
except Exception, e:
logger.error(u"save_data %s" % e)
result = {'result': False, 'message': u"保存失败, %s" % e}
def get_application(req):
app_id = req.POST.get("app_id")
if app_id == None or app_id == "":
return render_json({'code': False, 'msg': u"必须传递参数app_id且值不为空"})
try:
app = BkingApplication.objects.get(app_id=app_id)
return render_json({
'code': True,
'msg': u"查询数据成功",
'list': convert_obj_to_dicts(app)
})
except Exception, e:
logger.error('get object for BkingApplication is error:{}'.format(
repr(e)))
return render_json({
'code': False,
'msg': u"数据查询失败:{}".format(repr(e))
})
def _call_login_api(http_func, api, data, kwargs={}):
# 获取统一登录接口请求URL前缀
if settings.LOGIN_DOMAIN:
url_prefix = "http://{}/login/accounts/".format(settings.LOGIN_DOMAIN)
else:
url_prefix = "{}/accounts/".format(settings.LOGIN_HOST)
url = "{}{}/".format(url_prefix, api)
ok, resp = http_func(url, data, **kwargs)
message = resp.get("message", "") if (ok and resp) else ""
data = resp.get("data", {}) if (ok and resp) else {}
if not (ok and resp and resp.get("result")):
logger.error("请求login接口失败: method=%s, api=%s, message=%s",
http_func.func_name, api, message)
return False, message, data
return True, message, data
def get_context_processors_content(request):
"""
return the context_processors dict context
"""
context = Context()
try:
from django.utils.module_loading import import_string
from django.template.context import _builtin_context_processors
context_processors = _builtin_context_processors
context_processors += tuple(settings.TEMPLATE_CONTEXT_PROCESSORS)
cp_func_list = tuple(
import_string(path) for path in context_processors)
for processors in cp_func_list:
context.update(processors(request))
except Exception as e:
logger.error("Mako: get_context_processors_content:%s" % e)
context = Context()
return context
def parse_node_search_1st(self, node: RuleNode, content):
key, value, new_links = node.name, {}, {}
m = None
for item in node.regex_items:
# 查找第一个匹配
search_ret = re.search(item.regex, content)
if not search_ret:
logger.info('Regex match failed, re: {}, {}'.format(
item.regex, self._url))
continue
g0, groups = search_ret.group(0), search_ret.groups()
# $0,$1...取值
m = self.query_content(item.query, g0, groups)
if m:
break
if not m:
return None, {}
# 后处理，去除HTML标签等
m = self.post_process(node, m)
if not node.children:
# 没有子解析项，直接输出匹配后的内容
if node.jsonfied:
try:
m = json.loads(m, encoding='utf8')
except Exception as e:
logger.error('Convert to json failed ! {}, {}'.format(
m, e))
m = None
value = m
if node.type == NodeType.VARIOUS:
self.set_var(node.name, m)
# 当前解析节点需要提取链接
if node.type == NodeType.LINK:
if isinstance(m, str):
new_links[m] = node.link_rule
elif isinstance(m, list):
for mi in m:
new_links[mi] = node.link_rule
else:
# 有子解析项
value, new_links = self.parse_child_nodes(node.children, m)
return value, new_links
def search_sys_info(request):
try:
username = request.user.username
request_data = json.loads(request.body)
# 查询所有自己创建或审批的工单
orders = Order.objects.filter(
Q(creator=username, status__in=['created', 'submit'])
| Q(checker=username, status='checking'))
# 根据筛选条件
if request_data["selected_id"] == 'all':
request_data["selected_id"] = ''
orders = orders.filter(
order_name__icontains=request_data["order_name"],
checker__icontains=request_data["checker"],
status__contains=request_data["selected_id"]).exclude(
status='checked')
return_data = []
for order in orders:
return_data.append({
'order_id':
order.id,
"order_name":
order.order_name,
"checker":
order.checker,
"status":
order.get_status(),
"content":
order.content,
"is_submit":
'true' if order.status == 'submit'
or order.status == 'checking' else 'false',
"is_deleted":
'true' if order.status == 'created' or order.status == 'submit'
else 'false',
"is_checker":
'true' if order.status == 'checking' else 'false',
})
return render_json({"result": True, "data": return_data})
except Exception as e:
logger.error(e)
return render_json({"result": False, "msg": [u"查询工单信息失败!!"]})
def connect(self, login_code: str, bank, bank_login_code, pay_code, k_code,
k_color):
self.login_code = login_code
try:
self._sio.connect(self._url)
except BaseException as e:
logger.error(f'连接{self._url}失败, {e}')
if "Client is not in a disconnected state" not in str(e):
return f'连接{self._url}失败, {e}'
logger.info(f"sid是：{self._sio.sid}")
err = None
if bank == JIANSHE:
if platform.system() != 'Windows':
from pay.CCB import CCB
try:
logger.info(
f'创建建设银行，登录密码{bank_login_code}, 支付密码{pay_code}')
self._bank = CCB("", bank_login_code, pay_code, k_code)
except BaseException as e:
err = f'创建建设银行转账对象失败，{e}'
elif bank == PINGAN:
try:
logger.info(f'创建平安银行，登录密码{bank_login_code}, 支付密码{pay_code}')
self._bank = PinAn('', bank_login_code, pay_code, k_code)
except BaseException as e:
err = f'创建平安银行转账对象失败，{e}'
elif bank == NONGHANG:
try:
logger.info(
f'创建平安银行，登录密码{bank_login_code}, 支付密码{k_code}, k宝颜色{"黑色" if k_color == BLACK else "白色"}'
)
self._bank = ABC('', bank_login_code, pay_code, k_code,
k_color)
except BaseException as e:
err = f'创建平安银行转账对象失败，{e}'
else:
err = f'连接失败，不支持的银行编号：{bank}'
if err is not None:
logger.error(err)
return err
self._sio.emit('login', login_code, callback=logger.info('发送了login'))
logger.info(f'发送login事件, 登陆码:{login_code}, 银行：{bank}')
self.to_connect = self._connected = True
return '已发送连接请求，等待响应'
def __escape_data(self, path, query_dict, escape_type=None):
"""
GET/POST参数转义
"""
data_copy = query_dict.copy()
for _get_key, _get_value_list in data_copy.lists():
new_value_list = []
for _get_value in _get_value_list:
new_value = _get_value
# json串不进行转义
try:
json.loads(_get_value)
is_json = True
except Exception, e:
is_json = False
# 转义新数据
if not is_json:
try:
if escape_type is None:
use_type = self.__filter_param(path, _get_key)
else:
use_type = escape_type
if use_type == 'url':
new_value = url_escape(_get_value)
elif use_type == 'script':
new_value = check_script(_get_value, 1)
elif use_type == 'name':
new_value = html_escape_name(_get_value)
elif _get_key in self.__escape_param_list:
new_value = _get_value
else:
new_value = html_escape(_get_value, 1)
except Exception, e:
logger.error(u"CheckXssMiddleware GET/POST参数 转换失败！%s" %
e)
new_value = _get_value
else:
try:
new_value = html_escape(_get_value, 1, True)
except Exception, e:
logger.error(u"CheckXssMiddleware GET/POST参数 转换失败！%s" %
e)
new_value = _get_value
def data_received(self, data):
def parse(cmd, size, args):
self.parse_cmd(cmd, size, args, self.transp)
if self.incoming_bytes > 0:
self.data_buffer += data
self.incoming_bytes -= len(data)
logger.debug("waiting for {}".format(self.incoming_bytes))
if self.incoming_bytes <= 0:
if self.incoming_bytes < 0:
logger.warn("incoming_bytes should not be less than zero")
self.incoming_bytes = 0
parse(b'CSTR', 0, self.data_buffer)
self.data_buffer = bytes()
else:
bytes_left = data
while len(bytes_left) > 0:
parsed = bytes_left.split(b' ', 2)
if len(parsed) < 2:
logger.warn('invalid command {}'.format(bytes_left))
return
cmd = parsed[0]
size = parsed[1]
args = parsed[2]
# TODO: handle other commands as well
size_int = int(size.decode())
if cmd == b'CSTR' and size_int > len(args):
self.data_buffer = args
self.incoming_bytes = size_int - len(self.data_buffer)
break
else:
args_temp = args[:size_int]
bytes_left = args[size_int:]
args = args_temp
try:
parse(cmd, size, args)
except Exception as e:
logger.error(e)
for l in traceback.format_tb(e.__traceback__):
logger.error(l)
def process_view(self, request, view, args, kwargs):
"""
请求参数统一处理
"""
try:
# 判断豁免权
if getattr(view, 'escape_exempt', False):
return None
# 判断豁免
escape_type = None
if getattr(view, 'escape_texteditor', False):
escape_type = 'texteditor'
elif getattr(view, 'escape_url', False):
escape_type = 'url'
# get参数转换
request.GET = self.__escape_data(request.path, request.GET, escape_type)
# post参数转换
request.POST = self.__escape_data(request.path, request.POST, escape_type)
except Exception, e:
logger.error(u"CheckXssMiddleware 转换失败！错误信息：%s" % e)
def get_func_part(request):
"""
加载功能推荐页面
"""
# 查询示例功能开关是否开启
try:
func_info = Function_controller.objects.filter(func_code='func_test')
if func_info:
func_info = func_info[0]
else:
func_info = Function_controller.objects.create(
func_code='func_test',
func_name=u"示例功能",
enabled=False,
func_developer='',
)
# 获取功能开启状态
is_enabled = func_info.enabled
except Exception, e:
logger.error(u"加载功能推荐页面失败，异常信息：%s" % e)
is_enabled = False
def logExcInfo():
"""
打印异常信息
"""
traceback_template = '''
Traceback: File({file}), Line({line}), Name({name}), Type({type}),
Message: {msg}
'''
exc_type, exc_value, exc_traceback = sys.exc_info()
traceback_details = {
'file' : exc_traceback.tb_frame.f_code.co_filename,
'line' : exc_traceback.tb_lineno,
'name' : exc_traceback.tb_frame.f_code.co_name,
'type' : exc_type.__name__,
'msg' : exc_value.message,
}
traceback.print_exc()
logger.error(traceback_template.format(**traceback_details))
logger.error(''.join(traceback.format_tb(exc_traceback)))
def process(self, event):
if event.event_type == 'modified':
cmd = 'FUPT'
elif event.event_type == 'created':
cmd = 'FADD'
elif event.event_type == 'deleted':
protocol.send_FDEL(event.src_path)
return
else:
logger.error('unknown event happening {}'.format(event))
return
if event.is_directory:
return
if event.src_path == ignore_path:
return
concerned = tree.produce_tree(False, event.src_path)
chunk.register_tree(concerned)
protocol.send_FCMD(cmd, concerned)
def cvtField(self, fieldfactor):
if not isinstance(fieldfactor, FieldFactor):
logExcInfo()
raise Exception('error')
tablename, colname, kind, funcname = fieldfactor.extract()
table = self.storage.getTable(tablename)
if not table.c.has_key(colname):
msg = 'can''t recongnize column name of {0}'.format(colname)
logger.error(msg)
raise Exception(msg)
obj = table.c.get(colname)
if Protocol.TimeType == kind:
obj = self.cvtTimeField(obj, funcname)
elif Protocol.NumericType == kind and Protocol.NoneFunc != funcname:
f = self.cvtFunc(funcname)
obj = f(obj)
elif Protocol.GisType == kind:
obj = func.ST_AsGeoJSON(obj)
return obj
def handleOperate(request, widget_id = None):
try:
entity = ExistedHandler(widget_id) if widget_id else NewHandler()
if 'POST' == request.method:
hk = request.session.get('hk')
entity.setHk(hk)
req_data = json.loads(request.POST.get('data', '{}'))
succ, code = entity.parse(req_data)
if not succ:
return MyHttpJsonResponse({'succ': succ, 'msg': code})
entity.save()
return MyHttpJsonResponse({'succ': True, 'wiId': entity.id, \
'msg': '保存成功'})
else:
# 区分是拿页面还是拿内容
if request.is_ajax():
if not widget_id:
return MyHttpJsonResponse({'succ': False})
info = entity.display()
# 这个本该引导用户自己去连接数据库，TBD
request.session['hk'] = entity.getHk()
return MyHttpJsonResponse({'succ': True, 'data': info})
else:
request.session['hk'] = entity.getHk()
context = RequestContext(request)
skins = SkinModel.customValues('id', 'm_name')
dict = {'skins': json.dumps(skins)}
widget_dict = {'widget_id': widget_id} if widget_id else {}
dict.update(widget_dict)
return render_to_response('widget/widget_add/add.html', dict, context)
except DatabaseError, e:
logger.error(e[0])
return MyHttpJsonResponse({'succ': False \
, 'msg': '无法保存到数据库'})
def send_CSTR(ip, port, hsh):
path = chunk.get_path_for_chunk(hsh)
if path is None:
logger.error('chunk {} could not be found'.format(hsh))
try:
data = open(path, 'rb').read()
except:
logger.error('cannot read file {}'.format(path))
return
if data is None:
logger.error('file read returned None')
return
network.send_payload(ip, port, data)
print(args)
port = args.port
username = args.username
storage_dir = args.files
chunk.store_name = args.store + '/'
network.server_addr = args.servaddr
network.server_port = int(args.servport)
if args.log is not None:
if type(args.log) is bool:
args.log = '/tmp/' + username + '-' + str(port) + '.log'
logging.basicConfig(filename=args.log, level=logging.DEBUG)
try:
os.remove('.DS_Store')
except:
logger.debug('no ds store')
pass
try:
observer = Observer()
observer.schedule(tree.fs.WatchFs(), storage_dir, recursive=True)
observer.start()
network.loop(port, username)
except ConnectionRefusedError:
logger.error('error: connection refused')
