def DELETE(self, name):
""" 删除当前存储中的群集 """
res = {"msg": None, "code": 0, "success": False}
logger.info("the name that will delete is %s" % name)
if name in ("leader", "active", "all"):
res.update(msg="DELETE: name reserved for the system key words",
code=-1031)
elif self.isActive(name):
res.update(msg="DELETE: not allowed to delete the active cluster",
code=-1032)
elif self.isMember(name):
swarm = self.getOne(name)
logger.info("Will delete swarm cluster is %s" % swarm)
self._swarms.remove(swarm)
if self.isMember(name):
logger.info("Delete fail")
res.update(success=False)
else:
logger.info("Delete successfully, pickle current swarm")
self._pickle(self._swarms)
res.update(success=True)
else:
res.update(msg="DELETE: this swarm cluster does not exist",
code=-1030)
logger.info(res)
return res
def getUserProfile(self, uid, getBind=False):
""" 查询用户资料
@param uid str: 用户id
"""
res = dict(msg=None, code=1)
key = "passport:user:profile:{}".format(uid)
try:
if self.cache_enable is False:
raise
data = json.loads(self.redis.get(key))
if data:
logger.info("Hit getUserProfile Cache")
else:
raise
except:
sql = "SELECT register_source,register_ip,nick_name,domain_name,gender,birthday,signature,avatar,location,ctime,mtime,is_realname,is_admin,lock_nick_name,lock_domain_name FROM user_profile WHERE uid=%s"
if uid and isinstance(uid, (str, unicode)) and len(uid) == 22:
try:
data = self.mysql.get(sql, uid)
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="System is abnormal")
else:
res.update(data=data, code=0)
pipe = self.redis.pipeline()
pipe.set(key, json.dumps(data))
pipe.expire(key, 3600)
pipe.execute()
else:
res.update(msg="There are invalid parameters", code=2)
def listUserApp(self):
""" 查询userapp应用列表 """
res = dict(msg=None, code=1)
key = "passport:user:apps"
try:
if self.cache_enable is False:
raise
data = json.loads(self.redis.get(key))
if data:
logger.info("Hit listUserApps Cache")
else:
raise
except:
sql = "SELECT id,name,description,app_id,app_secret,app_redirect_url,ctime,mtime FROM sso_apps"
try:
data = self.mysql.query(sql)
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="System is abnormal")
else:
res.update(data=data, code=0)
pipe = self.redis.pipeline()
pipe.set(key, json.dumps(data))
pipe.expire(key, 600)
pipe.execute()
def get(self):
""" 查询私有仓 """
query = request.args.get("q")
ImageName = request.args.get("ImageName")
ImageId = request.args.get("ImageId")
tag = request.args.get("tag")
res = {"msg": None, "data": None}
if query == "url":
res.update(data=g.registry.url)
elif query == "status":
res.update(data=g.registry.status)
elif query == "version":
res.update(data=g.registry.version)
elif query == "all_repository":
res.update(data=g.registry._list_all_repository)
elif query == "all_tag":
res.update(data=g.registry._list_repository_tag(ImageName))
elif query == "all_imageId_ancestry":
res.update(data=g.registry._list_imageId_ancestry(ImageId))
elif query == "imageId_info":
res.update(data=g.registry._get_imageId_info(ImageId))
logger.info(res)
return res
def GET(self, get, **kwargs):
res = {"msg": None, "code": 0}
checkState = kwargs.get("checkState", False)
UpdateManager = kwargs.get("UpdateManager", False)
logger.info("get %s request, the query params is %s" % (get, kwargs))
if not isinstance(get, (str, unicode)) or not get:
res.update(msg="GET: query params type error or none", code=-1010)
else:
get = get.lower()
if get == "all":
res.update(data=self.getSwarm(checkState, UpdateManager))
elif get == "active":
res.update(data=self.getActive)
elif get == "leader":
res.update(data=self._checkSwarmLeader(self.getActive))
elif get == "member":
res.update(data=self.getMember)
elif get == "method":
res.update(data=self.getMethod)
else:
if self.isMember(get):
res.update(data=self.getOne(get))
else:
res.update(msg="No such swarm", code=-1011)
logger.info(res)
return res
def unbind(self, uid, identity_type):
"""解绑账号，要求已经登录系统
参数：
@param uid str: 用户id
@param identity_type int: 账号类型，参见`oauth2_name2type`函数
流程：
1. 检测此`identity_type`是否是否为注册源
2. 是注册源（使用此`identity_type`直接登录用户）：
2.1 只有绑定了邮箱、手机以及设置了密码才允许解绑；
2.2 上一条校验通过，则删除`user_auth`中`identity_type`对应条目
3. 不是注册源（使用此`identity_type`绑定的用户）：
3.1 直接删除`user_auth`中`identity_type`对应条目
"""
res = dict(msg=None, code=1)
if uid and identity_type and identity_type in (3, 4, 5, 6, 7, 8, 9):
register_source = self.__get_registerSource(uid)
if register_source and isinstance(register_source, int):
if register_source == identity_type:
# 是注册源流程
identity_types = self.__list_identity_type(uid)
if 2 in identity_types or 1 in identity_types:
# 这里需设计为绑定了2-email、3-mobile时已经设置密码
res.update(self.__remove_identity_type(uid, identity_type))
else:
res.update(msg="Please bind the email or phone first", code=2)
else:
# 非注册源流程
res.update(self.__remove_identity_type(uid, identity_type))
else:
res.update(msg="System is abnormal")
else:
res.update(msg="Check failed")
logger.info(res)
return res
def usersecurity():
res = dict(msg=None, code=1)
Action = request.args.get("Action")
if request.method == "GET":
if Action == "getSessions":
sd = analysis_sessionId(request.cookies.get("sessionId"))
if sd:
res.update(code=0)
data = dict()
# 获取当前会话
if request.args.get("getCurrentSession", True) in (True, "True", "true"):
browserType, browserDevice, browserOs, browserFamily = parse_userAgent(request.headers.get("User-Agent"))
area = getIpArea(g.ip)
if len(area.split()) >= 3:
area = area.split()[2]
CurrentSession = dict(iat=sd['iat'], exp=sd['exp'], browser=dict(family=" ".join(browserFamily.split()[:-1]), os=browserOs), ip=g.ip, area=area)
if g.sid:
CurrentSession["session"] = g.api.usersso.ssoGetWithSid(g.sid, True)
data["CurrentSession"]=CurrentSession
# 获取其他会话
if request.args.get("getOtherSession") in (True, "True", "true"):
OtherSession = [ g.api.usersso.ssoGetWithSid(sid, True) for sid in g.api.usersso.ssoGetRegisteredUserSid(g.uid) if g.sid != sid and g.api.usersso.ssoExistWithSid(sid) ]
data["OtherSession"] = OtherSession
res["data"] = data
elif Action == "getLoginHistory":
# 获取登录历史
sort = request.args.get("sort") or "desc"
page = request.args.get("page") or 1
limit = request.args.get("limit") or 10
res = g.api.userprofile.listUserLoginHistory(uid=g.uid, page=page, limit=limit, sort=sort)
logger.info(res)
return jsonify(dfr(res))
def userprofile():
res = dict(msg=None, code=1)
if request.method == "GET":
getBind = True if request.args.get("getBind") in ("true", "True", True) else False
res = g.api.userprofile.getUserProfile(g.uid, getBind)
elif request.method == "POST":
Action = request.args.get("Action")
if Action == "bindLauth":
account = request.form.get("account")
vcode = request.form.get("vcode")
password = request.form.get("password")
auth = Authentication()
res = auth.bindLauth(uid=g.uid, account=account, vcode=vcode, password=password)
if res["success"] == True and res["show_realname_tip"] == True:
res['set_realname'] = g.api.userprofile.updateUserRealname(g.uid)
elif request.method == "PUT":
"""修改个人资料，包含：基本资料、密码、头像、社交账号绑定"""
Action = request.args.get("Action")
if Action == "profile":
data = {k: v for k, v in request.form.iteritems() if k in ("nick_name", "domain_name", "birthday", "location", "gender", "signature")}
res = g.api.userprofile.updateUserProfile(uid=g.uid, **data)
if res["code"] == 0:
# 同步基本资料
g.api.usersso.clientsConSync(g.api.userapp.getUserApp, g.uid, dict(CallbackType="user_profile", CallbackData=data))
elif Action == "password":
nowpass = request.form.get("nowpass")
newpass = request.form.get("newpass")
repass = request.form.get("repass")
res = g.api.userprofile.updateUserPassword(uid=g.uid, nowpass=nowpass, newpass=newpass, repass=repass)
logger.info(res)
return jsonify(dfr(res))
def RollingUpgrade(self, serviceFlag, tag):
""" 服务滚动升级 """
res = {"msg": None, "code": 0}
logger.info("Update service flag(id/name) is %s, tag is %s" %
(serviceFlag, tag))
#check params
if not serviceFlag:
logger.warn("service id/name is empty")
res.update(msg="service id/name is empty", code=60000)
logger.info(res)
return res
if not tag:
res.update(msg="tag error", code=60001)
logger.info(res)
return res
#check leader
if not self.leader:
res.update(msg="No active swarm", code=-1000)
logger.info(res)
return res
data = self.GET(service=serviceFlag, core=True,
core_convert=False).get("data")[0]
Image = "{}:{}".format(data.get("Image").split(":")[0], tag)
res.update(self.PUT(serviceFlag, image=Image))
logger.info(res)
return res
def oauth2_signUp(self, openid, register_ip):
"""OAuth直接登录时注册入系统
@param openid str: 加密的openid，用以获取缓存中数据userinfo，格式是：
userinfo dict: 用户信息，必须包含`openid`,`identity_type`,`avatar`,`nick_name`
@param register_ip str: 注册IP地址
"""
res = dict(msg=None, success=False)
userinfo = self.__oauth2_getUserinfo(openid)
logger.debug(userinfo)
logger.debug(type(userinfo))
if userinfo and isinstance(userinfo, dict) and "avatar" in userinfo and "nick_name" in userinfo and "openid" in userinfo and "access_token" in userinfo and "identity_type" in userinfo:
openid = userinfo["openid"]
access_token = userinfo["access_token"]
identity_type = int(userinfo["identity_type"])
avatar = userinfo["avatar"]
nick_name = userinfo["nick_name"]
gender = int(userinfo.get("gender") or 2)
signature = userinfo.get("signature") or ""
location = userinfo.get("location") or ""
expire_time = userinfo.get("expire_time") or 0
guid = gen_uniqueId()
logger.debug("check test: guid length: {}, identifier: {}, identity_type:{}, identity_type: {}, certificate: {}".format(len(guid), openid, identity_type, type(identity_type), access_token))
define_profile_sql = "INSERT INTO user_profile (uid, register_source, register_ip, nick_name, gender, signature, avatar, location, ctime, is_realname, is_admin) VALUES ('%s', %d, '%s', '%s', %d, '%s', '%s', '%s', %d, %d, %d)" % (guid, identity_type, register_ip, nick_name, gender, signature, avatar, location, get_current_timestamp(), 0, 0)
upts = self.__signUp_transacion(guid=guid, identifier=openid, identity_type=identity_type, certificate=access_token, verified=1, register_ip=register_ip, expire_time=expire_time, define_profile_sql=define_profile_sql)
res.update(upts)
if res["success"]:
self.__oauth2_delUserinfo(openid)
res.update(identity_type=identity_type, uid=guid)
else:
res.update(msg="Check failed")
logger.info(res)
return res
def usermsg():
res = dict(msg=None, code=1)
Action = request.args.get("Action")
if request.method == "POST":
if Action == "addMessage":
res = g.api.usermsg.push_message(
g.uid, request.form.get("msgContent"),
request.form.get("msgType", "system"))
elif Action == "markMessage":
res = g.api.usermsg.markstatus_message(g.uid,
request.form.get("msgId"))
elif request.method == "GET":
if Action == "getCount":
res = g.api.usermsg.count_message(
g.uid,
request.args.get("msgStatus") or 1)
elif Action == "getList":
res = g.api.usermsg.pull_message(
g.uid,
request.args.get("msgStatus") or 1,
request.args.get("msgType"),
True if request.args.get("desc", True) in (True, "True",
"true") else False)
elif request.method == "DELETE":
if Action == "delMessage":
res = g.api.usermsg.delete_message(g.uid,
request.form.get("msgId"))
elif Action == "clearMessage":
res = g.api.usermsg.clear_message(g.uid)
logger.info(res)
return jsonify(dfr(res))
def userprofile():
res = dict(msg=None, code=1)
if request.method == "GET":
getBind = True if request.args.get("getBind") in ("true", "True",
True) else False
res = g.api.userprofile.getUserProfile(g.uid, getBind)
elif request.method == "PUT":
"""修改个人资料，包含：基本资料、密码、头像、社交账号绑定"""
Action = request.args.get("Action")
if Action == "profile":
data = {
k: v
for k, v in request.form.iteritems()
if k in ("nick_name", "domain_name", "birthday", "location",
"gender", "signature")
}
res = g.api.userprofile.updateUserProfile(uid=g.uid, **data)
if res["code"] == 0:
# 同步基本资料
g.api.usersso.clientsConSync(
g.api.userapp.getUserApp, g.uid,
dict(CallbackType="user_profile", CallbackData=data))
elif Action == "password":
nowpass = request.form.get("nowpass")
newpass = request.form.get("newpass")
repass = request.form.get("repass")
res = g.api.userprofile.updateUserPassword(uid=g.uid,
nowpass=nowpass,
newpass=newpass,
repass=repass)
logger.info(res)
return jsonify(dfr(res))
def POST(self, swarmName, swarmIp):
""" add a swarm cluster into current, check, pickle. """
res = {"msg": None, "code": 0}
swarmIp = swarmIp.strip()
swarmName = swarmName.strip()
logger.debug(
"post a swarm cluster, name is %s, ip is %s, check ip is %s" %
(swarmName, swarmIp, ip_check(swarmIp)))
if not swarmName or not swarmIp or not ip_check(swarmIp):
res.update(msg="POST: data params error", code=-1020)
elif self.isMember(swarmName):
res.update(msg="POST: swarm cluster already exists", code=-1021)
else:
#access node ip's info, and get all remote managers
url = Splice(netloc=swarmIp, port=self.port, path='/info').geturl
swarm = dict(name=swarmName)
logger.info(
"init a swarm cluter named %s, will get swarm ip info, that url is %s"
% (swarmName, url))
try:
nodeinfo = requests.get(url,
timeout=self.timeout,
verify=self.verify).json()
logger.debug("get swarm ip info, response is %s" % nodeinfo)
swarm["manager"] = [
nodes["Addr"].split(":")[0]
for nodes in nodeinfo["Swarm"]["RemoteManagers"]
]
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="POST: access the node ip has exception",
code=-1022)
else:
def __init__(self, port=2375, timeout=2, ActiveSwarm=None):
self.port = port
self.timeout = timeout
self.verify = False
self.swarm = ActiveSwarm
self.leader = self._checkSwarmLeader(self.swarm) if self.swarm != {} else None
logger.info("Network Api Init, ActiveSwarm is %s, the leader is %s" %(self.swarm, self.leader))
def oauth2_bindLogin(self, openid, account, password):
"""OAuth绑定账号并登录系统
@param openid str: 加密的openid
@param account str: 同`signIn`中account
@param password str: 同`signIn`中password
"""
res = dict(msg=None, success=False)
userinfo = self.__oauth2_getUserinfo(openid)
logger.debug(userinfo)
logger.debug(type(userinfo))
if userinfo and isinstance(userinfo, dict) and "avatar" in userinfo and "nick_name" in userinfo and "openid" in userinfo and "access_token" in userinfo and "identity_type" in userinfo:
res = self.signIn(account, password)
openid = userinfo["openid"]
logger.debug(res)
if res["success"] is True:
# 登录成功，即可绑定openid到uid，无需校验(goto_signUp已经校验)
uid = res["uid"]
access_token = userinfo["access_token"]
identity_type = int(userinfo["identity_type"])
expire_time = userinfo.get("expire_time") or 0
upts = self.__signUp_transacion(guid=uid, identifier=openid, identity_type=identity_type, certificate=access_token, verified=1, expire_time=expire_time, use_profile_sql=False)
res.update(upts)
if res["success"] is True:
self.__oauth2_delUserinfo(openid)
else:
res.update(msg="Check failed")
logger.info(res)
return res
def misc_getDownTime():
"""Vaptcha宕机模式
like: ?data=request&_t=1516092685906
"""
data = request.args.get("data")
logger.info("vaptcha into downtime, get data: {}, query string: {}".format(
data, request.args.to_dict()))
return jsonify(json.loads(vaptcha.downtime(data)))
def callback(result):
logger.info(result)
if result["sender"] == "up2local":
result["src"] = url_for("static",
filename=join(UPLOAD_FOLDER,
upload_path, filename),
_external=True)
data.append(dfr(result))
def post(self):
""" 创建网络 """
ip = request.form.get("ip")
role = request.form.get("role", "Worker")
logger.info(request.form)
return g.node.POST(ip=ip, role=role)
def __signUp_transacion(self, guid, identifier, identity_type, certificate, verified, register_ip="", expire_time=0, use_profile_sql=True, define_profile_sql=None):
''' begin的方式使用事务注册账号，
参数：
@param guid str: 系统账号唯一标识
@param identifier str: 手机号、邮箱或第三方openid
@param identity_type int: 账号类型，参见`oauth2_name2type`函数
@param certificate str: 加盐密码或第三方access_token
@param verified int: 是否已验证 0-未验证 1-已验证
@param register_ip str: 注册IP地址
@param expire_time int: 特指OAuth过期时间戳，暂时保留
@param use_profile_sql bool: 定义是否执行define_profile_sql
@param define_profile_sql str: 自定义写入`user_profile`表的sql(需要完整可直接执行SQL)
流程：
1、写入`user_auth`表
2、写入`user_profile`表
返回字典：
success bool 表示注册是否成功；
msg str 表示提示信息。
'''
res = dict(success=False, msg=None)
# 校验
if guid and identifier and \
identity_type and \
certificate and \
verified and \
isinstance(guid, (str, unicode)) and \
len(guid) == 22 and \
identity_type in (0, 1, 2, 3, 4, 5, 6, 7, 8, 9) and \
verified in (1, 0):
ctime = get_current_timestamp()
try:
logger.debug("transaction, start")
self.db._db.begin()
try:
sql_1 = "INSERT INTO user_auth (uid, identity_type, identifier, certificate, verified, status, ctime, etime) VALUES (%s, %s, %s, %s, %s, %s, %s, %s)"
info = self.db.insert(sql_1, guid, identity_type, identifier, certificate, verified, 1, ctime, expire_time)
except IntegrityError:
res.update(msg="Account already exists")
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="System is abnormal")
else:
if use_profile_sql is True:
if define_profile_sql:
sql_2 = define_profile_sql
logger.info("execute define_profile_sql: {}".format(sql_2))
try:
info = self.db.execute(sql_2)
except:
raise
else:
sql_2 = "INSERT INTO user_profile (uid, register_source, register_ip, ctime, is_realname, is_admin) VALUES (%s, %s, %s, %s, %s, %s)"
try:
info = self.db.insert(sql_2, guid, identity_type, register_ip, ctime, 0, 0)
except:
raise
logger.debug('transaction, commit')
self.db._db.commit()
def before_request():
g.requestId = gen_requestId()
g.username = request.cookies.get("username", "")
g.sessionId = request.cookies.get("sessionId", "")
g.expires = request.cookies.get("time", "")
g.credential = '.'.join([g.username, g.expires, g.sessionId])
g.signin = isLogged_in(g.credential)
logger.info("Start Once Access, this requestId is %s, signin:%s" %
(g.requestId, g.signin))
def _list_repository_tag(self, ImageName):
""" 列出某个镜像所有标签 """
ReqUrl = self._baseUrl + "/repositories/{}/tags".format(ImageName) if self.version == 1 else self._baseUrl + "/{}/tags/list".format(ImageName)
logger.info("_list_repository_tag for url {}".format(ReqUrl))
try:
Tags = requests.get(ReqUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
return {}
def _list_imageId_ancestry(self, ImageId):
""" 列出某个镜像所有父镜像 """
ReqUrl = self._baseUrl + "/images/{}/ancestry".format(ImageId)
logger.info("_list_imageId_ancestry for url {}".format(ReqUrl))
try:
ImageIds = requests.get(ReqUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
return False
def __init__(self, timeout=2, Registry={}):
self.timeout = timeout
self.verify = False
#Base Registry info
self._url = Registry["RegistryAddr"]
self._ver = Registry["RegistryVersion"]
self._auth = Registry["RegistryAuthentication"]
#Instantiation the registry
self._baseUrl = SpliceURL.Modify(self._url, path="/v1").geturl if int(self._ver) == 1 else SpliceURL.Modify(self._url, path="/v2").geturl
logger.info("Registry API Init, registry is {}, status is {}, _baseUrl is {}".format(self._url, self.status, self._baseUrl))
def _delete_repository(self, ImageName):
""" 删除一个镜像 """
ReqUrl = self._baseUrl + "/repositories/{}/".format(ImageName)
logger.info("_delete_repository for url {}".format(ReqUrl))
try:
delete_repo_result = requests.delete(ReqUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
return False
def _search_all_repository(self, q):
""" 搜索私有仓所有镜像 """
ReqUrl = self._baseUrl + "/search" if self.version == 1 else self._baseUrl + "/_catalog"
logger.info("_search_all_repository for url {}".format(ReqUrl))
try:
Images = requests.get(ReqUrl, timeout=self.timeout, verify=self.verify, params={"q": q}).json()
except Exception,e:
logger.error(e, exc_info=True)
return []
def post(self):
username = request.form.get("username", "")
sessionId = request.form.get("sessionId", "")
expires = request.form.get("time", "")
logger.debug(g.username)
logger.debug(g.sessionId)
logger.debug(g.expires)
signin = isLogged_in('.'.join([username, expires, sessionId]))
logger.info("CREATE SSO %s" % signin)
return {"success": signin}
def authorized():
""" Client SSO 单点登录、注销入口, 根据`Action`参数判断是`ssoLogin`还是`ssoLogout` """
Action = request.args.get("Action")
if Action == "ssoLogin":
# 单点登录
ticket = request.args.get("ticket")
if request.method == "GET" and ticket and g.signin == False:
resp = sso_request("{}/sso/validate".format(sso_server), dict(Action="validate_ticket"), dict(ticket=ticket, app_name=SSO["app_name"], get_userinfo=True, get_userbind=False))
logger.debug("SSO check ticket resp: {}".format(resp))
if resp and isinstance(resp, dict) and "success" in resp and "uid" in resp:
if resp["success"] is True:
uid = resp["uid"]
sid = resp["sid"]
expire = int(resp["expire"])
# 获取用户信息，若不需要，可将get_userinfo=True改为False，并注释下两行
g.userinfo = resp["userinfo"].get("data") or dict()
set_userinfo(uid, g.userinfo, expire)
logger.debug(g.userinfo)
# 授权令牌验证通过，设置局部会话，允许登录
sessionId = set_sessionId(uid=uid, seconds=expire, sid=sid)
response = make_response(redirect(get_redirect_url("front.index")))
response.set_cookie(key="sessionId", value=sessionId, max_age=expire, httponly=True, secure=False if request.url_root.split("://")[0] == "http" else True)
return response
elif Action == "ssoLogout":
# 单点注销
ReturnUrl = request.args.get("ReturnUrl") or get_referrer_url() or url_for("front.index", _external=True)
NextUrl = "{}/signOut?ReturnUrl={}".format(sso_server, ReturnUrl)
app_name = request.args.get("app_name")
if request.method == "GET" and NextUrl and app_name and g.signin == True and app_name == SSO["app_name"]:
response = make_response(redirect(NextUrl))
response.set_cookie(key="sessionId", value="", expires=0)
return response
elif Action == "ssoConSync":
# 数据同步：参数中必须包含大写的hmac_sha256(app_name:app_id:app_secret)的signature值
signature = request.args.get("signature")
if request.method == "POST" and signature and signature == hmac_sha256("{}:{}:{}".format(SSO["app_name"], SSO["app_id"], SSO["app_secret"])).upper():
try:
data = json.loads(request.form.get("data"))
ct = data["CallbackType"]
cd = data["CallbackData"]
uid = data["uid"]
token = data["token"]
except Exception,e:
logger.warning(e)
else:
logger.info("ssoConSync with uid: {} -> {}: {}".format(uid, ct, cd))
resp = sso_request("{}/sso/validate".format(sso_server), dict(Action="validate_sync"), dict(token=token, uid=uid))
if resp and isinstance(resp, dict) and resp.get("success") is True:
# 之后根据不同类型的ct处理cd
logger.debug("ssoConSync is ok")
if ct == "user_profile":
g.userinfo.update(cd)
elif ct == "user_avatar":
g.userinfo["avatar"] = cd
return jsonify(msg="Synchronization completed", success=set_userinfo(uid, g.userinfo), app_name=SSO["app_name"])
def UserAuth_Login(username, password):
sql = " SELECT lauth_username, lauth_password FROM user_lauth WHERE lauth_username=%s"
data= mysql.get(sql, username)
logger.debug("mysql data is %s, request %s:%s" %(data, username, md5(password)))
if data and username == data.get("lauth_username") and md5(password) == data.get("lauth_password"):
logger.info("%s Sign in successfully" %username)
return True
else:
logger.info("%s Sign in failed" %username)
return False
def _checkSwarmManager(self, ip):
""" 查询节点的Manager """
url = Splice(netloc=ip, port=self.port, path='/info').geturl
logger.info("Get or Update swarm manager, that url is %s" %url)
try:
nodeinfo = requests.get(url, timeout=self.timeout, verify=self.verify).json()
logger.debug("Get or Update swarm manager, response is %s" %nodeinfo)
managers = [ nodes["Addr"].split(":")[0] for nodes in nodeinfo["Swarm"]["RemoteManagers"] ]
except Exception,e:
logger.error(e, exc_info=True)
return []
def __init__(self, port=2375, timeout=2, ActiveSwarm={}):
self.port = port
self.verify = False
self.timeout = timeout
self.swarm = ActiveSwarm
self.leader = self._checkSwarmLeader(
self.swarm) if self.swarm != {} else None
self.commaConvert = lambda string: [
l for l in re.split(comma_Pat, string) if l
]
logger.info("Service Api Init, ActiveSwarm is %s, the leader is %s" %
(self.swarm, self.leader))
