def process(self, ssh, hostname):
result = BaseResponse()
try:
result.data = ssh(hostname, 'uname -a').decode("utf8")
except Exception as e:
logger.error(traceback.format_exc())
result.error = traceback.format_exc()
result.status = False
return result.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
result = ssh(hostname, 'dmidecode -t1')
response.data = self.parse(result)
except Exception as e:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
result = ssh(hostname, "ifconfig | grep 'inet ' -B1")
response.data = self.parse(result)
except Exception as e:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
info = ssh(hostname, 'df')
response.data = self.parse(info)
except Exception as xe:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
shell_command = "cat /proc/cpuinfo"
output = ssh(shell_command, hostname)
response.data = self.parse(output)
except Exception as e:
msg = traceback.format_exc()
response.status = False
response.error = msg
logger.error(msg)
return response.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
result = ssh(hostname, "free | awk 'NR>1{print $0}'")
# result = ssh(hostname, 'dmidecode -q -t 17 2> /dev/null')
response.data = self.parse(result)
except Exception as e:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def process(self, ssh, hostname):
# 假设执行了命令
result = BaseResponse()
try:
# output = ssh(hostname,"MegaCli -PDList -aALL")
with open(settings.LOCAL_DISK_FILE_PATH) as f:
output = f.read()
result.data = self.parse(output)
except Exception as e:
logger.error(traceback.format_exc())
result.status = False
result.error = traceback.format_exc()
return result.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
uname = ssh(hostname, 'uname').strip()
version = ssh(hostname, 'cat /etc/issue').strip().split('\n')[0]
response.data = {
'uname': uname,
'version': version,
}
except Exception as e:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def process(self, ssh, hostname):
response = BaseResponse()
try:
cmd1 = ssh(hostname, 'sudo ip link show')
cmd2 = ssh(hostname, 'sudo ip addr show')
result = self._interfaces_ip(cmd1 + '\n' + cmd2)
response.data = result
except Exception as e:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def handler(accid, openids):
for openid in openids:
logger.info("处理[{}]中".format(openid))
userinfo = WechatAccUser(accid=accid,
isAccessToken=True).get_info(openid)
logger.info("获取列表[{}]".format(userinfo))
if userinfo['subscribe'] == 0:
continue
with transaction.atomic():
try:
accUserObj = AccLinkUser.objects.get(accid=accid,
openid=openid)
accUserObj.tags = json.dumps(userinfo['tagid_list']).replace(
" ", "")
accUserObj.nickname = userinfo['nickname']
accUserObj.sex = userinfo['sex']
accUserObj.city = userinfo['city']
accUserObj.province = userinfo['province']
accUserObj.country = userinfo['country']
accUserObj.headimgurl = userinfo['headimgurl']
accUserObj.subscribe_time = userinfo['subscribe_time']
accUserObj.subscribe_scene = userinfo['subscribe_scene']
accUserObj.umark = '0'
accUserObj.save()
except AccLinkUser.DoesNotExist:
try:
AccLinkUser.objects.create(
**dict(accid=accid,
openid=userinfo['openid'],
tags=json.dumps(userinfo['tagid_list']).replace(
" ", ""),
nickname=userinfo['nickname'],
sex=userinfo['sex'],
city=userinfo['city'],
province=userinfo['province'],
country=userinfo['country'],
headimgurl=userinfo['headimgurl'],
subscribe_time=userinfo['subscribe_time'],
subscribe_scene=userinfo['subscribe_scene'],
umark='0'))
except Exception as e:
logger.error(str(e))
def wrapped(request, *args, **kwds):
# Init params
params = kwds.get('params', {})
info = Info.objects.all()
if (len(info) == 0):
logger.error("Info is empty!!!")
elif (len(info) > 1):
logger.error("Info contains more than one record!!!")
params["info"] = info[0]
else:
params["info"] = info[0]
kwds['params'] = params
# Execute original function
return f(request, *args, **kwds)
def send_request_other(url, method='get', params=None, data=None, headers={}):
logger.info("请求参数: url:{} header:{} body:{} params:{}".format(
url, headers, data, params))
try:
result = request(method,
url,
params=params,
json=data,
verify=False,
headers=headers)
status_code = result.status_code
result = result.json()
print(result)
if str(status_code) == '200':
return result
except Exception as ex:
logger.error('{0} 调用失败:{1}'.format(url, ex))
raise PubErrorCustom('{0}'.format(ex))
def process(self, ssh, hostname):
response = BaseResponse()
try:
uname = ssh(hostname, 'uname').strip()
version = ssh(hostname,
'cat /etc/redhat-release').strip().split('\n')[0]
cpu_count = ssh(
hostname,
'cat /proc/cpuinfo | grep "physical id" | uniq | wc -l ')
kernel_version = ssh(hostname, 'uname -r')
response.data = {
'uname': uname,
'version': version,
'cpu_count': cpu_count,
'kernel_version': kernel_version
}
except Exception:
logger.error(traceback.format_exc())
response.status = False
response.error = traceback.format_exc()
return response.dict
def handler(accid, res):
for item in res:
with transaction.atomic():
try:
atObj = AccTag.objects.get(id=item['id'])
atObj.name = item['name']
atObj.fans_count = item['count']
atObj.wechat_fans_count = item['count']
atObj.umark = '0'
atObj.save()
except AccTag.DoesNotExist:
try:
AccTag.objects.create(
**dict(id=item['id'],
accid=accid,
name=item['name'],
fans_count=item['count'],
wechat_fans_count=item['count'],
umark='0'))
except Exception as e:
logger.error(str(e))
def send_request(url,
token=None,
method='get',
params=None,
data=None,
headers={}):
logger.info("请求参数: url:{} header:{} body:{}".format(url, headers, data))
print(ServerUrl + url)
try:
result = request(method,
ServerUrl + url,
params=params,
json=data,
verify=False,
headers=headers)
# status_code = result.status_code
result = result.json()
logger.info(result)
if str(result.get('rescode')) == '10000':
return result.get('data') if 'data' in result else {}
raise PubErrorCustom(result.get('msg'))
except Exception as ex:
logger.error('{0} 调用失败:{1}'.format(url, ex))
raise PubErrorCustom('{0}'.format(ex))
import time, json
import time, json
def eventHandler(self):
logger.info(self.xml_data)
if self.xml_data['MsgType'] == 'event':
"""
扫描带参数二维码事件
"""
if (self.xml_data['Event'] == 'subscribe'
and 'EventKey' in self.xml_data
and self.xml_data.get("EventKey")
) or self.xml_data['Event'] == 'SCAN':
if self.xml_data['Event'] == 'SCAN':
"""
如果用户已经关注公众号，则微信会将带场景值扫描事件推送给开发者
"""
try:
aqc_obj = AccQrcode.objects.select_for_update().get(
id=self.xml_data['EventKey'])
except AccQrcode.DoesNotExist:
logger.info("未找到此渠道二维码{}".format(self.xml_data))
return "success"
self.ActionHandler('4')
self.ActionHandler('2')
aqc_obj.tot_count += 1
aqc_obj.follow_count += 1
aqc_obj.save()
else:
"""
如果用户还未关注公众号，则用户可以关注公众号，关注后微信会将带场景值关注事件推送给开发者
"""
try:
aqc_obj = AccQrcode.objects.select_for_update().get(
id=self.xml_data['EventKey'].split("qrscene_")[1])
except AccQrcode.DoesNotExist:
logger.info("未找到此渠道二维码{}".format(self.xml_data))
return "success"
self.ActionHandler('4')
self.ActionHandler('1')
aqc_obj.tot_count += 1
aqc_obj.new_count += 1
aqc_obj.save()
"""
先给此用户打标签
"""
for item in json.loads(aqc_obj.tags):
WeChatAccTag(
auth_accesstoken=self.auth_accesstoken).batchtagging(
[self.xml_data['FromUserName']], item)
userinfo = self.linkUser()
#推送消息
if aqc_obj.qr_type == '0':
return self.msgHandler(send_type=aqc_obj.send_type,
listids=aqc_obj.listids,
user={
"openid": userinfo['openid'],
"nickname": userinfo['nickname']
})
else:
return "success"
elif self.xml_data['Event'] == 'subscribe':
if self.acc.follow_setting != '0':
return "success"
else:
try:
obj = AccFollow.objects.get(accid=self.acc.accid)
except AccFollow.DoesNotExist:
logger.error("公众号{}无设置{}".format(
self.acc.accid, self.xml_data))
return "success"
if obj.send_type == '0':
send_type = '1'
elif obj.send_type == '1':
send_type = '2'
elif obj.send_type == '2':
send_type = '0'
else:
logger.error("公众号{}推送标志有误!".format(self.acc.accid))
userinfo = self.linkUser()
self.ActionHandler('1')
self.ReplyCustom(type='0', userinfo=userinfo)
return self.msgHandler(send_type=send_type,
obj=AccFollowModelSerializer1(
obj, many=False).data,
listids=obj.listids,
user={
"openid": userinfo['openid'],
"nickname": userinfo['nickname']
})
elif self.xml_data['Event'] == 'unsubscribe':
try:
aobj = AccLinkUser.objects.get(
accid=self.acc.accid,
openid=self.xml_data['FromUserName'])
aobj.umark = '1'
aobj.save()
except AccLinkUser.DoesNotExist:
pass
self.ActionHandler('3')
elif self.xml_data['Event'] == 'CLICK':
userinfo = self.linkUser()
self.ActionHandler('5')
self.ReplyCustom(type='2', userinfo=userinfo)
elif self.xml_data['Event'] == 'VIEW':
userinfo = self.linkUser()
self.ActionHandler('5')
else:
logger.error("事件未定义{}".format(self.xml_data))
return "success"
elif self.xml_data['MsgType'] == 'text':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'image':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'voice':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'video':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'shortvideo':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'location':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
elif self.xml_data['MsgType'] == 'link':
userinfo = self.linkUser()
self.ActionHandler('0')
self.ReplyCustom(type='1', userinfo=userinfo)
else:
logger.error("消息类型错误!{}".format(self.xml_data['MsgType']))
return "success"
return "success"
def __init__(self,
model,
train_params,
batch_processor,
train_data,
val_data=None):
assert isinstance(train_params, TrainParams)
self.params = train_params
# Data loaders
self.train_data = train_data
self.val_data = val_data # sDataLoader.copy(val_data) if isinstance(val_data, DataLoader) else val_data
# self.val_stream = self.val_data.get_stream() if self.val_data else None
self.batch_processor = batch_processor
self.batch_per_epoch = len(self.train_data)
# set CUDA_VISIBLE_DEVICES=gpus
gpus = ','.join([str(x) for x in self.params.gpus])
os.environ['CUDA_VISIBLE_DEVICES'] = gpus
self.params.gpus = tuple(range(len(self.params.gpus)))
logger.info('Set CUDA_VISIBLE_DEVICES to {}...'.format(gpus))
# Optimizer and learning rate
self.last_epoch = 0
self.optimizer = self.params.optimizer # type: Optimizer
if not isinstance(self.optimizer, Optimizer):
logger.error('optimizer should be an instance of Optimizer, '
'but got {}'.format(type(self.optimizer)))
raise ValueError
self.lr_scheduler = self.params.lr_scheduler # type: ReduceLROnPlateau or _LRScheduler
if self.lr_scheduler and not isinstance(
self.lr_scheduler, (ReduceLROnPlateau, _LRScheduler)):
logger.error(
'lr_scheduler should be an instance of _LRScheduler or ReduceLROnPlateau, '
'but got {}'.format(type(self.lr_scheduler)))
raise ValueError
logger.info('Set lr_scheduler to {}'.format(type(self.lr_scheduler)))
self.log_values = OrderedDict()
self.batch_timer = Timer()
self.data_timer = Timer()
# load model
self.model = model
ckpt = self.params.ckpt
if not self.params.save_dir:
self.params.save_dir = os.path.join('outputs',
self.params.exp_name)
mkdir(self.params.save_dir)
logger.info('Set output dir to {}'.format(self.params.save_dir))
if ckpt is None:
# find the last ckpt
ckpts = [
fname for fname in os.listdir(self.params.save_dir)
if os.path.splitext(fname)[-1] == '.h5'
]
ckpt = os.path.join(
self.params.save_dir,
sorted(ckpts,
key=lambda name: int(
os.path.splitext(name)[0].split('_')[-1]))
[-1]) if len(ckpts) > 0 else None
if ckpt is not None and not self.params.re_init:
self._load_ckpt(ckpt)
logger.info('Load ckpt from {}'.format(ckpt))
self.model = ListDataParallel(self.model, device_ids=self.params.gpus)
self.model = self.model.cuda(self.params.gpus[0])
self.model.train()
if self.params.subnet_name != 'keypoint_subnet':
self.model.module.freeze_bn(
) # nn.BatchNorm2d.eval() if not 'keypoint_subnet'
total = 0
next_openid = False
while count == 0 or count < total:
res = WechatAccUser(accid=accid,
isAccessToken=True).get_user_list(next_openid)
logger.info("获取列表[{}]".format(res))
handler(accid, res['data']['openid'])
count += res['count']
total = res['total']
next_openid = res['next_openid']
print(count, total)
logger.info("公众号[{}]粉丝同步[{}]处理完毕!".format(accid,
UtilTime().arrow_to_string()))
if __name__ == '__main__':
"""
同步粉丝列表
"""
accid = sys.argv[1]
try:
sync(accid)
except Exception as e:
logger.error(str(e))
