def GitHub_Login_Page_State(code,
GITHUB_APP_ID,
GITHUB_APP_KEY,
GITHUB_REDIRECT_URI,
timeout=5,
verify=False):
''' Authorization Code cannot repeat '''
Access_Token_Url = Splice(scheme="https",
domain="github.com",
path="/login/oauth/access_token",
query={
"client_id": GITHUB_APP_ID,
"client_secret": GITHUB_APP_KEY,
"code": code,
"redirect_uri": GITHUB_REDIRECT_URI
}).geturl
data = requests.post(Access_Token_Url, timeout=timeout, verify=verify).text
data = Parse_Access_Token(data)
if "access_token" in data:
access_token = data.get("access_token")
User_Info_Url = Splice(scheme="https",
domain="api.github.com",
path="/user",
query={
"access_token": access_token
}).geturl
data = requests.get(User_Info_Url, timeout=timeout,
verify=verify).json()
username = "******" + data.get("login")
user_id = data.get("id")
user_github = data.get("html_url")
user_cname = data.get("name")
user_avater = data.get("avatar_url")
user_email = data.get("email")
user_extra = "blog:%s, company:%s, location:%s" % (
data.get("blog"), data.get("company"), data.get("location"))
try:
UserSQL = "INSERT INTO User (username, cname, email, avatar, time, github, extra) VALUES (%s, %s, %s, %s, %s, %s, %s)"
mysql.insert(UserSQL, username, user_cname, user_email,
user_avater, How_Much_Time(), user_github, user_extra)
OAuthSQL = "INSERT INTO OAuth (oauth_username, oauth_type, oauth_openid, oauth_access_token, oauth_expires) VALUES (%s, %s, %s, %s, %s)"
mysql.insert(OAuthSQL, username, "GitHub", user_id, access_token,
How_Much_Time())
except IntegrityError, e:
logger.debug(e, exc_info=True)
#Check if it has been registered
CheckSQL = "SELECT oauth_username FROM OAuth WHERE oauth_username=%s"
if mysql.get(CheckSQL, username):
UpdateSQL = "UPDATE OAuth SET oauth_access_token=%s, oauth_expires=%s, oauth_openid=%s WHERE oauth_username=%s"
mysql.update(UpdateSQL, access_token, How_Much_Time(), user_id,
username)
#update user profile
UpdateUserSQL = "UPDATE User SET cname=%s, avatar=%s, extra=%s WHERE username=%s"
mysql.update(UpdateUserSQL, user_cname, user_avater,
user_extra, username)
return {"username": username, "uid": user_id}
except Exception, e:
logger.error(e, exc_info=True)
return False
def _checkSwarmLeader(self, swarm):
""" 查询swarm集群Leader """
logger.info("check swarm %s leader, the request swarm manager is %s" %
(swarm.get("name"), swarm.get("manager")))
if swarm:
try:
url = Splice(netloc=swarm.get("manager")[0],
port=self.port,
path='/nodes').geturl
data = requests.get(url,
timeout=self.timeout,
verify=self.verify).json()
if "message" in data:
raise TypeError(
"The response that first get leader is error, data is {}"
.format(data))
except Exception, e:
logger.warn(e, exc_info=True)
try:
url = Splice(netloc=swarm.get("manager")[-1],
port=self.port,
path='/nodes').geturl
data = requests.get(url,
timeout=self.timeout,
verify=self.verify).json()
except Exception, e:
logger.error(e, exc_info=True)
data = None
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 QQ_Login_Page_State(code,
QQ_APP_ID,
QQ_APP_KEY,
QQ_REDIRECT_URI,
timeout=5,
verify=False):
''' Authorization Code cannot repeat '''
QQ_Access_Token_Url = Splice(scheme="https",
domain="graph.qq.com",
path="/oauth2.0/token",
query={
"grant_type": "authorization_code",
"client_id": QQ_APP_ID,
"client_secret": QQ_APP_KEY,
"code": code,
"state": "P.passport",
"redirect_uri": QQ_REDIRECT_URI
}).geturl
access_token_data = requests.get(QQ_Access_Token_Url,
timeout=timeout,
verify=verify).text
try:
data = Parse_Access_Token(access_token_data)
except Exception, e:
logger.error(e, exc_info=True)
data = Callback_Returned_To_Dict(access_token_data)
def DELETE(self, serviceFlag):
#delete a service
res = {"msg": None, "code": 0}
logger.info(serviceFlag)
if not self.leader:
res.update(msg="No active swarm", code=-1000)
logger.info(res)
return res
if not serviceFlag:
res.update(msg="no service id or name<%s>" % serviceFlag,
code=50100)
logger.info(res)
return res
logger.info("delete service, check parameters pass")
try:
SwarmEngineServiceDeleteUrl = Splice(netloc=self.leader,
port=self.port,
path="/services/%s" %
serviceFlag).geturl
SwarmEngineServiceDeleteRes = requests.delete(
SwarmEngineServiceDeleteUrl,
timeout=self.timeout,
verify=self.verify)
SwarmEngineServiceDeleteCode = SwarmEngineServiceDeleteRes.status_code
except Exception, e:
logger.error(e, exc_info=True)
res.update(success=False,
code=50200,
msg="delete service<%s> fail" % serviceFlag)
def _checkSwarmHealth(self, leader):
""" 根据Leader查询某swarm集群是否健康 """
state = []
mnum = 0
logger.info(
"To determine whether the cluster is healthy, starting, swarm leader is %s"
% leader)
try:
nodes = requests.get(Splice(netloc=leader,
port=self.port,
path='/nodes').geturl,
timeout=self.timeout,
verify=self.verify).json()
logger.debug("check swarm health, swarm nodes length is %d" %
len(nodes))
for node in nodes:
if node['Spec'].get('Role') == 'manager':
mnum += 1
isHealth = True if node['Status'][
'State'] == 'ready' and node['Spec'].get(
'Availability') == 'active' and node.get(
'ManagerStatus', {}).get(
'Reachability') == 'reachable' else False
if isHealth:
state.append(isHealth)
except Exception, e:
logger.warn(e, exc_info=True)
return "ERROR"
def _checkServiceTaskNode(self, leader, serviceId):
""" 查询某service(ID)的实例节点 """
url = Splice(netloc=leader, port=self.port, path='/tasks').geturl
logger.info("Get service %s task, that url is %s" % (serviceId, url))
data = requests.get(url,
params={
"filters":
json.dumps(
{'desired-state': {
'running': True
}})
}).json()
#data = requests.get(url).json()
nodes = [
_['NodeID'] for _ in data if _['Status']['State'] == 'running'
and _['ServiceID'] == serviceId
]
ips = []
for node in nodes:
nodeinfo = self._checkSwarmNode(leader, node)
ip = nodeinfo.get('ManagerStatus', {}).get(
'Addr', '').split(':')[0] or nodeinfo['Spec'].get(
'Labels', {}).get('ipaddr')
ips.append(ip)
return {"ips": ips, "nodes": nodes}
def Get_Access_Token(code):
''' Authorization Code cannot repeat '''
Get_Access_Token_Url = Splice(scheme="https",
netloc="api.instagram.com",
path="/oauth/access_token",
query={
"client_id": INSTAGRAM_APP_ID,
"client_secret": INSTAGRAM_APP_KEY,
"code": code,
"redirect_uri": REDIRECT_URI
}).geturl
access_token_data = requests.post(Get_Access_Token_Url,
timeout=timeout,
verify=verify,
proxies=proxies).json()
"""
{
"access_token": "fb2e77d.47a0479900504cb3ab4a1f626d174d2d",
"user": {
"id": "1574083",
"username": "******",
"full_name": "Snoop Dogg",
"profile_picture": "..."
}
}
"""
if isinstance(access_token_data, dict):
return access_token_data
else:
raise ServerError("Get Access Token Error with Authorization Code")
def _checkSwarmNetwork(self, leader, networkId=None):
""" 查询集群网络 """
try:
path = "/networks/" + networkId if networkId else "/networks"
NetUrl = Splice(netloc=leader, port=self.port, path=path).geturl
NetData = requests.get(NetUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
def _checkSwarmToken(self, leader):
""" 根据Leader查询集群令牌 """
try:
swarm = requests.get(Splice(netloc=leader, port=self.port, path='/swarm').geturl, timeout=self.timeout, verify=self.verify).json()
token = swarm.get('JoinTokens')
except Exception,e:
logger.warn(e, exc_info=True)
def _checkSwarmNode(self, leader, node=None):
""" 查询集群节点 """
try:
path = "/nodes/" + node if node else "/nodes"
NodeUrl = Splice(netloc=leader, port=self.port, path=path).geturl
NodeData = requests.get(NodeUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
def GitHub_Login_Page_Url(GITHUB_APP_ID, GITHUB_REDIRECT_URI):
''' Redirect GitHub Landing Page URL '''
return Splice(scheme="https",
domain="github.com",
path="/login/oauth/authorize",
query={
"client_id": GITHUB_APP_ID,
"redirect_uri": GITHUB_REDIRECT_URI
}).geturl
def _checkSwarmNodeinfo(self, ip):
""" 查询节点信息 """
try:
NodeUrl = Splice(netloc=ip, port=self.port, path="/info").geturl
NodeInfo = requests.get(NodeUrl, timeout=self.timeout, verify=self.verify).json()
except Exception,e:
logger.error(e, exc_info=True)
return {}
def Get_User_Info(access_token, uid):
User_Info_Url = Splice(scheme="https",
netloc="api.weibo.com",
path="/2/users/show.json",
query={
"access_token": access_token,
"uid": uid
}).geturl
return requests.get(User_Info_Url, timeout=timeout, verify=verify).json()
def Get_Authorization_Code():
''' Redirect GitHub Landing Page URL '''
return Splice(scheme="https",
netloc="github.com",
path="/login/oauth/authorize",
query={
"client_id": GITHUB_APP_ID,
"redirect_uri": REDIRECT_URI
}).geturl
def Get_User_Info(access_token):
Get_User_Info_Url = Splice(scheme="https",
netloc="api.github.com",
path="/user",
query={
"access_token": access_token
}).geturl
return requests.get(Get_User_Info_Url, timeout=timeout,
verify=verify).json()
def Update_Access_Token(refresh_token):
'''Update some required parameters for OAuth2.0 API calls'''
Update_Access_Token_Url = Splice(scheme="https", netloc="graph.qq.com", path="/oauth2.0/token", query={"grant_type": "refresh_token", "client_id": QQ_APP_ID, "client_secret": QQ_APP_KEY, "refresh_token": refresh_token}).geturl
access_token_data = requests.get(Update_Access_Token_Url, timeout=timeout, verify=verify).text
try:
data = Parse_Access_Token(access_token_data)
except Exception,e:
app.logger.error(e, exc_info=True)
data = Callback_Returned_To_Dict(access_token_data)
def Weibo_Login_Page_Url(WEIBO_APP_ID, WEIBO_REDIRECT_URI):
''' Redirect Weibo Landing Page URL '''
return Splice(scheme="https",
domain="api.weibo.com",
path="/oauth2/authorize",
query={
"response_type": "code",
"client_id": WEIBO_APP_ID,
"redirect_uri": WEIBO_REDIRECT_URI
}).geturl
def Get_Authorization_Code():
''' Redirect Weibo Landing Page URL '''
return Splice(scheme="https",
netloc="api.weibo.com",
path="/oauth2/authorize",
query={
"response_type": "code",
"client_id": WEIBO_APP_ID,
"redirect_uri": REDIRECT_URI
}).geturl
def Get_Authorization_Code():
''' Redirect GitHub Landing Page URL '''
return Splice(scheme="https",
netloc="api.instagram.com",
path="/oauth/authorize/",
query={
"client_id": INSTAGRAM_APP_ID,
"redirect_uri": REDIRECT_URI,
"response_type": "code"
}).geturl
def QQ_Login_Page_Url(QQ_APP_ID, QQ_REDIRECT_URI):
''' Redirect QQ Landing Page URL '''
return Splice(scheme="https",
domain="graph.qq.com",
path="/oauth2.0/authorize",
query={
"response_type": "code",
"client_id": QQ_APP_ID,
"redirect_uri": QQ_REDIRECT_URI,
"scope": "get_user_info"
}).geturl
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 Get_User_Info(access_token):
Get_User_Info_Url = Splice(scheme="https",
netloc="api.instagram.com",
path="/v1/users/self/",
query={
"access_token": access_token
}).geturl
return requests.get(Get_User_Info_Url,
timeout=timeout,
verify=verify,
proxies=proxies).json()
"""
def Get_Access_Token(code):
''' Authorization Code cannot repeat '''
Access_Token_Url = Splice(scheme="https",
netloc="api.weibo.com",
path="/oauth2/access_token",
query={
"grant_type": "authorization_code",
"client_id": WEIBO_APP_ID,
"client_secret": WEIBO_APP_KEY,
"code": code,
"redirect_uri": REDIRECT_URI
}).geturl
return requests.post(Access_Token_Url, timeout=timeout,
verify=verify).json()
def Get_Access_Token(code):
''' Authorization Code cannot repeat '''
Get_Access_Token_Url = Splice(scheme="https",
netloc="github.com",
path="/login/oauth/access_token",
query={
"client_id": GITHUB_APP_ID,
"client_secret": GITHUB_APP_KEY,
"code": code,
"redirect_uri": REDIRECT_URI
}).geturl
access_token_data = requests.post(Get_Access_Token_Url,
timeout=timeout,
verify=verify).text
data = Parse_Access_Token(access_token_data)
#Should returned right data, such as {'access_token': '79D493208A237BAB3C9AE93FAD2798CE', 'expires_in': '7776000', 'refresh_token': '30AF0BD336324575029492BD2D1E134B'}
if isinstance(data, dict):
return data
else:
raise ServerError("Get Access Token Error with Authorization Code")
def InitSwarm(self, AdvertiseAddr, ForceNewCluster=False):
""" 初始化集群 """
res = {"msg": None, "code": 0, "success": False}
AdvertiseAddr = AdvertiseAddr.strip()
ForceNewCluster = True if ForceNewCluster in ("true", "True",
True) else False
url = Splice(netloc=AdvertiseAddr, port=self.port,
path='/swarm/init').geturl
try:
r = requests.post(url,
data=json.dumps({
"ListenAddr":
"0.0.0.0",
"AdvertiseAddr":
AdvertiseAddr,
"ForceNewCluster":
ForceNewCluster
}),
headers={"Content-Type": "application/json"})
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="Node Error", code=-1001)
def Weibo_Login_Page_State(code,
WEIBO_APP_ID,
WEIBO_APP_KEY,
WEIBO_REDIRECT_URI,
timeout=5,
verify=False):
''' Authorization Code cannot repeat '''
Access_Token_Url = Splice(scheme="https",
domain="api.weibo.com",
path="/oauth2/access_token",
query={
"grant_type": "authorization_code",
"client_id": WEIBO_APP_ID,
"client_secret": WEIBO_APP_KEY,
"code": code,
"redirect_uri": WEIBO_REDIRECT_URI
}).geturl
data = requests.post(Access_Token_Url, timeout=timeout,
verify=verify).json()
if "access_token" in data:
access_token = data.get("access_token")
expires_in = data.get("expires_in")
uid = requests.get(
"https://api.weibo.com/2/account/get_uid.json?access_token=%s" %
access_token,
timeout=timeout,
verify=verify).json().get("uid", data.get("uid"))
User_Info_Url = Splice(scheme="https",
domain="api.weibo.com",
path="/2/users/show.json",
query={
"access_token": access_token,
"uid": uid
}).geturl
data = requests.get(User_Info_Url, timeout=timeout,
verify=verify).json()
logger.debug(data)
username = "******" + access_token[4:13]
user_cname = data.get("screen_name")
user_avater = data.get("profile_image_url")
user_weibo = "http://weibo.com/" + data.get("profile_url")
user_extra = data.get("description")
user_gender = u"男" if data.get("gender") == "m" else u"女"
try:
UserSQL = "INSERT INTO User (username, cname, avatar, time, weibo, gender, extra) VALUES (%s, %s, %s, %s, %s, %s, %s)"
mysql.insert(UserSQL, username, user_cname, user_avater,
How_Much_Time(), user_weibo, user_gender, user_extra)
OAuthSQL = "INSERT INTO OAuth (oauth_username, oauth_type, oauth_openid, oauth_access_token, oauth_expires) VALUES (%s, %s, %s, %s, %s)"
mysql.insert(OAuthSQL, username, "Weibo", uid, access_token,
How_Much_Time(seconds=int(expires_in)))
except IntegrityError, e:
logger.debug(e, exc_info=True)
#Check if it has been registered
CheckSQL = "SELECT oauth_username FROM OAuth WHERE oauth_username=%s"
if mysql.get(CheckSQL, username):
UpdateSQL = "UPDATE OAuth SET oauth_access_token=%s, oauth_expires=%s, oauth_openid=%s WHERE oauth_username=%s"
mysql.update(UpdateSQL, access_token,
How_Much_Time(seconds=int(expires_in)), uid,
username)
#update user profile
UpdateUserSQL = "UPDATE User SET cname=%s, avatar=%s, weibo=%s, gender=%s, extra=%s WHERE username=%s"
mysql.update(UpdateUserSQL, user_cname, user_avater,
user_weibo, user_gender, user_extra, username)
return {
"username": username,
"expires_in": expires_in,
"uid": uid
}
except Exception, e:
logger.error(e, exc_info=True)
return False
data = Parse_Access_Token(access_token_data)
except Exception, e:
logger.error(e, exc_info=True)
data = Callback_Returned_To_Dict(access_token_data)
#Should returned right data, such as {'access_token': '79D493208A237BAB3C9AE93FAD2798CE', 'expires_in': '7776000', 'refresh_token': '30AF0BD336324575029492BD2D1E134B'}
if "refresh_token" in data:
#access_token = data.get("access_token")
#expires_in = data.get("expires_in")
refresh_token = data.get("refresh_token")
'''Update some required parameters for OAuth2.0 API calls'''
Update_Access_Token_Url = Splice(scheme="https",
domain="graph.qq.com",
path="/oauth2.0/token",
query={
"grant_type": "refresh_token",
"client_id": QQ_APP_ID,
"client_secret": QQ_APP_KEY,
"refresh_token": refresh_token
}).geturl
access_token_data = requests.get(Update_Access_Token_Url,
timeout=timeout,
verify=verify).text
try:
data = Parse_Access_Token(access_token_data)
except Exception, e:
logger.error(e, exc_info=True)
data = Callback_Returned_To_Dict(access_token_data)
if "access_token" in data:
def GET(self, service=None, core=False, core_convert=False):
res = {"msg": None, "code": 0, "data": ()}
if self.leader:
ServiceUrl = Splice(
netloc=self.leader,
port=self.port,
path="/services/%s" % service).geturl if service else Splice(
netloc=self.leader, port=self.port,
path="/services").geturl
logger.info(
"Get service url is %s, core is %s, core_convert is %s" %
(ServiceUrl, core, core_convert))
try:
r = requests.get(ServiceUrl,
timeout=self.timeout,
verify=self.verify)
services = r.json()
services = services if isinstance(services,
(list,
tuple)) else (services, )
services_core = []
except Exception, e:
logger.error(e, exc_info=True)
res.update(msg="Retrieve service fail", code=30000)
else:
if r.status_code == 404:
res.update(msg="No such service<%s>" % service,
data=[],
code=30010)
logger.info(res)
return res
elif core == False:
res.update(data=services)
elif core == True and core_convert == True:
try:
for i in services:
logger.debug(i)
i_ID = i.get("ID")
i_Name = i.get("Spec", {}).get("Name")
i_CreatedAt = timeChange(i.get("CreatedAt"))
i_UpdatedAt = timeChange(i.get("UpdatedAt"))
i_Labels = i.get("Spec", {}).get("Labels")
i_Image = i.get("Spec", {}).get(
"TaskTemplate", {}).get("ContainerSpec",
{}).get("Image")
i_Env = i.get("Spec",
{}).get("TaskTemplate",
{}).get("ContainerSpec",
{}).get("Env")
#### start convert mount
i_Mounts = i.get("Spec", {}).get(
"TaskTemplate", {}).get("ContainerSpec",
{}).get("Mounts", [])
_i_Mounts = []
for _ in i_Mounts:
_i_Mounts.append(
"%s:%s:%s:%s" %
(_.get("Source"), _.get("Target"),
_.get("ReadOnly", ""), _.get("Type", "")))
i_Mounts = _i_Mounts
#### end convert mount
i_Replicas = "global" if "Global" in i.get(
"Spec", {}).get("Mode", {}) else i.get(
"Spec", {}).get("Mode", {}).get(
"Replicated", {}).get("Replicas")
i_NetMode = i.get("Endpoint", {}).get(
"Spec",
{}).get("Mode") or i.get("Spec", {}).get(
"EndpointSpec", {}).get("Mode")
#### start convert publish
i_NetPorts = i.get("Endpoint",
{}).get("Spec",
{}).get("Ports", [])
_i_NetPorts = []
for _ in i_NetPorts:
_i_NetPorts.append(
"%s:%s:%s" %
(_.get("PublishedPort"),
_.get("TargetPort"), _.get("Protocol")))
i_NetPorts = _i_NetPorts
#### end convert publish
#### start convert vip
i_NetVip = i.get("Endpoint",
{}).get("VirtualIPs", [])
_i_NetVip = []
for _ in i_NetVip:
_i_NetVip.append(_.get("Addr"))
i_NetVip = _i_NetVip
#### end convert vip
i_Version = i.get("Version", {}).get("Index")
i_UpdateStatus = "%s(%s)" % (
i.get("UpdateStatus").get("State"),
timeChange(
i.get("UpdateStatus").get("CompletedAt"))
) if i.get("UpdateStatus").get("State") else None
services_core.append({
"ID": i_ID,
"Name": i_Name,
"CreatedAt": i_CreatedAt,
"UpdatedAt": i_UpdatedAt,
"Labels": i_Labels,
"Image": i_Image,
"Env": i_Env,
"Mounts": i_Mounts,
"Replicas": i_Replicas,
"NetMode": i_NetMode,
"NetPorts": i_NetPorts,
"NetVip": i_NetVip,
"Version": i_Version,
"UpdateStatus": i_UpdateStatus
})
except Exception, e:
logger.error(e, exc_info=True)
else:
res.update(data=services_core)
elif core == True and core_convert == False:
try:
for i in services:
logger.debug(i)
services_core.append({
"ID":
i.get("ID"),
"Name":
i.get("Spec", {}).get("Name"),
"CreatedAt":
i.get("CreatedAt"),
"UpdatedAt":
i.get("UpdatedAt"),
"Labels":
i.get("Spec", {}).get("Labels"),
"Image":
i.get("Spec",
{}).get("TaskTemplate",
{}).get("ContainerSpec",
{}).get("Image"),
"Env":
i.get("Spec",
{}).get("TaskTemplate",
{}).get("ContainerSpec",
{}).get("Env"),
"Mounts":
i.get("Spec",
{}).get("TaskTemplate",
{}).get("ContainerSpec",
{}).get("Mounts", []),
"Replicas":
i.get("Spec", {}).get("Mode", {}).get(
"Replicated", {}).get("Replicas")
or "global",
"NetMode":
i.get("Endpoint", {}).get("Spec",
{}).get("Mode")
or i.get("Spec", {}).get("EndpointSpec",
{}).get("Mode"),
"NetPorts":
i.get("Endpoint", {}).get("Spec",
{}).get("Ports"),
"NetVip":
i.get("Endpoint", {}).get("VirtualIPs"),
"Version":
i.get("Version", {}).get("Index"),
"UpdateStatus":
"%s(%s)" %
(i.get("UpdateStatus").get("State"),
i.get("UpdateStatus").get("CompletedAt"))
if i.get("UpdateStatus").get("State") else None
})
except Exception, e:
logger.error(e, exc_info=True)
from SpliceURL import Splice, Split, Modify
if __name__ == "__main__":
print Splice(netloc='http://127.0.0.1', query={"username": "******", "password": "******", "id": True}).geturl
print Split("http://www.saintic.com/blog/?blogId=110&token=true&sso=false").do()
print Modify("http://www.saintic.com/blog", path='show/', query={"blogId": 115, "Token": "abcdefghjqmnoprstuvwxyz"}).geturl
