def __init__(self, report):
self.query = Query()
self.forms = HTMLutils()
self.report = report
self.columns = loadYaml('columns')
self.pages = loadYaml('pages')
if report == 'add':
page = 'edit'
else:
page = report
self.display_names = self.getDisplayNames(page)
def apiOperWithLogin(user, servers, id, verb, noun, queryParams, data):
resp = doAPIOper(servers, id, verb, noun, queryParams, data)
if resp is not None and resp.status_code == 401 and 'NeedLogin' in resp.json(
) and resp.json()['NeedLogin']:
#print(json.dumps(resp.json()))
cfg = utils.loadYaml("{0}/.{1}/{1}.users.yaml".format(
utils.getHome(), "kcluster"))
oidclogin.login(cfg[user]['provider'].lower(), "kcluster")
# update token & try again
cfg = utils.loadYaml("{0}/.{1}/{1}.users.yaml".format(
utils.getHome(), "kcluster"))
queryParams['id_token'] = cfg[user]['tokens']['id_token']
return doAPIOper(servers, id, verb, noun, queryParams, data)
else:
return resp
def argsToQuery(user=None,
workspec=None,
status=None,
workcfg=None,
workfile=None,
origspec=None,
workuser=None,
dataPut=None):
queryParams = {}
data = dataPut
if user is not None:
home = utils.getHome()
cfgfile = "{0}/.{1}/{1}.users.yaml".format(home, "kcluster")
cfg = utils.loadYaml(cfgfile)
queryParams['provider'] = cfg[user]['provider']
queryParams['id_token'] = cfg[user]['tokens']['id_token']
else: # worktoken
queryParams['work_token'] = os.environ["KC_WORKTOKEN"]
if status is not None:
queryParams['status'] = status
if workuser is not None:
queryParams['workuser'] = workuser
if workspec is not None:
if data is None:
data = {}
data.update({
'spec': workspec, # this work's spec - a map
'origspec': origspec, # original spec without mods - a map
'workfile': workfile # the raw file as string
})
if workcfg is not None:
data['workcfg'] = workcfg # a map
return queryParams, data
def main(argv):
parser = argparse.ArgumentParser(
"kubectl.py",
description=
"Run kubectl commands on cluster, any arguments not parsed here will be passed directly to kubectl"
)
parser.add_argument("--id",
default=None,
help="Context ID of cluster to operate on")
parser.add_argument("-u", "--user", default=None)
parser.add_argument("-n", "--namespace", default=None)
args, remargs = parser.parse_known_args(argv)
(args.id, args.user) = getCtx(args.id, args.user, None)
# move default config as it may conflict, register to remove
moveExistConfig()
cfgdir = "{0}/.kcluster/{1}".format(utils.getHome(), args.id)
serverInfo = utils.loadYaml("{0}/servers.yaml".format(cfgdir))
servers = serverInfo["Servers"]
servers = [
re.sub('(.*):(.*)', '\g<1>:{0}'.format(serverInfo["k8sport"]), s)
for s in servers
]
(queryParams, _) = argsToQuery(user=args.user)
webutils.tryServers(
servers, partial(doOper, args.user, args.id, remargs, args.namespace),
partial(getServers, queryParams))
def getKubeServers(cfgdir):
serverInfo = utils.loadYaml("{0}/servers.yaml".format(cfgdir))
servers = serverInfo["Servers"]
servers = [
re.sub('(.*):(.*)', '\g<1>:{0}'.format(serverInfo["k8sport"]), s)
for s in servers
]
return servers
def getKubeStr(user, id, kubeargstr, namespace, server):
cfgdir = "{0}/.kcluster/{1}".format(utils.getHome(), id)
base = "{0}/{1}".format(cfgdir, user)
if namespace is None:
namespace = utils.loadYaml(
"{0}/users.yaml".format(cfgdir))[user]['namespace']
cmd = ("kubectl --server={0} --namespace={1} "
"--certificate-authority={2}/ca-kube.pem "
"--client-certificate={3}-kube.pem "
"--client-key={3}-kube-key.pem {4}".format(server, namespace,
cfgdir, base,
kubeargstr))
#print(cmd)
return cmd
def serversWithPort(id, port, http=None):
cfgdir = "{0}/.kcluster/{1}".format(utils.getHome(), id)
serverInfo = utils.loadYaml("{0}/servers.yaml".format(cfgdir))
servers = serverInfo["Servers"]
if http is None:
return [
re.sub('(.*):(.*)', '\g<1>:{0}'.format(port), s) for s in servers
]
else:
return [
re.sub('(.*)://(.*):(.*)', '{0}://\g<2>:{1}'.format(http, port), s)
for s in servers
]
return servers
def doKubeOper(user, id, kubeargs, namespace=None, servers=None):
moveExistConfig()
if servers is None:
cfgdir = "{0}/.kcluster/{1}".format(utils.getHome(), id)
serverInfo = utils.loadYaml("{0}/servers.yaml".format(cfgdir))
servers = serverInfo["Servers"]
servers = [
re.sub('(.*):(.*)', '\g<1>:{0}'.format(serverInfo["k8sport"]), s)
for s in servers
]
#print("SERVERS: {0}".format(servers))
doOperFn = lambda server: doOper(user, id, kubeargs, namespace, server,
True)
out = webutils.tryServers(servers, doOperFn, None)
return out.stdout.decode(), out
def fileIter(workfile, user, status, workcfg, workuser, workcfgupdate=None):
if workfile is not None:
with open(workfile, 'r') as fp:
workfilecontent = fp.read()
else:
workfilecontent = utils.b64d(os.environ["KC_WORKFILE"])
if workcfg is not None:
workcfgcontent = utils.loadYaml(workcfg) # a map
elif "KC_WORKCFG" in os.environ:
workcfgcontent = yaml.safe_load(utils.b64d(
os.environ["KC_WORKCFG"])) # a map
else:
workcfgcontent = None
if workcfgcontent is not None and workcfgupdate is not None:
workcfgcontent.update(workcfgupdate)
return specIter(user, status, workcfgcontent, workfilecontent, workuser)
def getUser(id, user):
if user is None:
cfgfile = "{0}/.{1}/{1}.users.yaml".format(utils.getHome(), "kcluster")
if not os.path.exists(cfgfile) and id is not None:
cfgfile = "{0}/.{1}/{2}/users.yaml".format(utils.getHome(),
"kcluster", id)
# if id is None:
# cfgfile = "{0}/.{1}/{1}.users.yaml".format(utils.getHome(), "kcluster")
# else:
# cfgfile = "{0}/.{1}/{2}/users.yaml".format(utils.getHome(), "kcluster", id)
cfg = utils.loadYaml(cfgfile)
if len(list(cfg)) > 1:
print("User must be specified - one of {0}".format(list(cfg)))
exit()
user = list(cfg)[0]
return user
def getCtx(id, user, server, setcontext=False):
ctxFile = '{0}/.kcluster/context.yaml'.format(utils.getHome())
if os.path.exists(ctxFile) and not setcontext:
ctx = utils.loadYaml(ctxFile)
if id is None:
id = ctx['ClusterID']
else:
id = getCtxId(id, server)
if user is None:
user = ctx['User']
else:
user = getUser(id, user)
else:
id = getCtxId(id, server)
user = getUser(id, user)
return id, user
def __init__(self):
self.htmlUtils = HTMLutils()
self.series = Series()
self.author = Author()
self.dynamicJS = DynamicJS()
self.columns = loadYaml('columns')
#get form values
form = cgi.FieldStorage(keep_blank_values = 1)
self.form_values = {}
keys =[]
for k in form.keys():
key = str(k)
value = str(form.getvalue(key))
self.form_values[key] = value
self.book_id= 328
self.activity= 'view'
def __init__(self, form_dict):
"""initialize variables and bring in column metadata"""
self.book_id = form_dict["book_id"]
self.activity = form_dict["activity"]
self.connection = getDictConnection()
self.columns = loadYaml("columns")
self.author = Author()
self.record_dict = dict.copy(form_dict)
self.added_new_rec = False
del self.record_dict["book_id"]
del self.record_dict["activity"]
if self.activity == "submit_new":
start_sql = 'insert into book (title) values ("starter")'
start = execute(self.connection, start_sql)
find_sql = "select book_id from book where title like 'starter'"
find = execute(self.connection, find_sql)
self.book_id = find[0]["book_id"]
self.activity = "update"
self.added_new_rec = True
def dumpKubeCreds(user, resp, id):
cfgdir = utils.getHome() + "/.kcluster/{0}".format(id)
print("Writing {0} to {1}".format(resp, cfgdir))
with open('{0}/ca-kube.pem'.format(cfgdir), 'w') as fp:
fp.write(resp['CA'])
with open('{0}/{1}-kube.pem'.format(cfgdir, user), 'w') as fp:
fp.write(resp['Cert'])
with open('{0}/{1}-kube-key.pem'.format(cfgdir, user), 'w') as fp:
fp.write(resp['Key'])
with open('{0}/{1}-kube.config'.format(cfgdir, user), 'w') as fp:
# create config file
yaml.safe_dump(createKubeConfig(cfgdir, resp), fp)
# also merge into kubeconfig
if ctxName is None:
cname = getKubeServers(cfgdir)[0].split('//')[1].split('.')[0].split(
'-infra')[0]
else:
cname = ctxName
uname = cname + '-' + user
kcfg = createKubeConfig(cfgdir,
resp,
clustername=cname,
username=uname,
contextname=uname)
basecfg = utils.getHome() + '/.kube/config'
if os.path.exists(basecfg):
baseYaml = utils.loadYaml(basecfg)
baseYaml['clusters'] = removeDups(baseYaml['clusters'], cname)
baseYaml['users'] = removeDups(baseYaml['users'], uname)
baseYaml['contexts'] = removeDups(baseYaml['contexts'], uname)
newYaml = utils.deepmerge(kcfg, baseYaml)
fd, name = tempfile.mkstemp()
utils.dumpYaml(newYaml, name)
print("merging configuration into {0}".format(basecfg))
shutil.copy(name, basecfg)
os.close(fd)
os.remove(name)
def decodeOIDCToken(cfgfile, user=None):
cfg = utils.loadYaml("{0}/.{1}/{1}.users.yaml".format(utils.getHome(), cfgfile))
if user is None:
user = list(cfg)[0]
return validateJWTFn[cfg[user]['provider']](cfg[user]['tokens']['id_token'])
def __init__(self):
self.connection = getDictConnection()
self.columns = loadYaml('columns')
def __init__(self):
self.columns = loadYaml('columns')
self.pages = loadYaml('pages')
self.tablejoins = loadYaml('tablejoins')
self.connection = getDictConnection()
self.conn = getConnection()
