449 lines
13 KiB
Python
Executable File
449 lines
13 KiB
Python
Executable File
#!/usr/bin/python3
|
|
import json
|
|
import os
|
|
import getopt
|
|
|
|
import sys, inspect
|
|
this_folder = os.path.realpath(os.path.abspath(os.path.split(inspect.getfile(inspect.currentframe()))[0]))
|
|
src_folder = os.path.realpath(os.path.abspath(os.path.join(this_folder,"..", "src")))
|
|
if src_folder not in sys.path:
|
|
sys.path.insert(0, src_folder)
|
|
|
|
# must first init loadenv
|
|
import tools, env
|
|
config = env.getenv("CONFIG")
|
|
tools.loadenv(config)
|
|
|
|
from webViews.log import initlogging
|
|
initlogging("docklet-web")
|
|
from webViews.log import logger
|
|
|
|
from flask import Flask, request, session, render_template, redirect, send_from_directory, make_response, url_for, abort
|
|
from webViews.dashboard import dashboardView
|
|
from webViews.user.userlist import userlistView, useraddView, usermodifyView, groupaddView, userdataView, userqueryView
|
|
from webViews.user.userinfo import userinfoView
|
|
from webViews.user.userActivate import userActivateView
|
|
from webViews.user.grouplist import grouplistView, groupqueryView, groupdetailView, groupmodifyView
|
|
from functools import wraps
|
|
from webViews.dockletrequest import dockletRequest
|
|
from webViews.cluster import *
|
|
from webViews.admin import *
|
|
from webViews.monitor import *
|
|
from webViews.authenticate.auth import login_required, administration_required,activated_required
|
|
from webViews.authenticate.register import registerView
|
|
from webViews.authenticate.login import loginView, logoutView
|
|
import webViews.dockletrequest
|
|
from webViews import cookie_tool
|
|
|
|
|
|
|
|
|
|
|
|
external_login = env.getenv('EXTERNAL_LOGIN')
|
|
#default config
|
|
external_login_url = '/external_auth/'
|
|
external_login_callback_url = '/external_auth_callback/'
|
|
if (external_login == 'True'):
|
|
sys.path.insert(0, os.path.realpath(os.path.abspath(os.path.join(this_folder,"../src", "plugin"))))
|
|
import external_generate
|
|
from webViews.authenticate.login import external_loginView, external_login_callbackView
|
|
external_login_url = external_generate.external_login_url
|
|
external_login_callback_url = external_generate.external_login_callback_url
|
|
|
|
|
|
app = Flask(__name__)
|
|
|
|
|
|
|
|
@app.route("/", methods=['GET'])
|
|
def home():
|
|
return render_template('home.html')
|
|
|
|
@app.route("/login/", methods=['GET', 'POST'])
|
|
def login():
|
|
return loginView.as_view()
|
|
|
|
@app.route(external_login_url, methods=['GET'])
|
|
def external_login_func():
|
|
try:
|
|
return external_loginView.as_view()
|
|
except:
|
|
abort(404)
|
|
|
|
@app.route(external_login_callback_url, methods=['GET'])
|
|
def external_login_callback():
|
|
try:
|
|
return external_login_callbackView.as_view()
|
|
except:
|
|
abort(404)
|
|
|
|
@app.route("/logout/", methods=["GET"])
|
|
@login_required
|
|
def logout():
|
|
return logoutView.as_view()
|
|
|
|
@app.route("/register/", methods=['GET', 'POST'])
|
|
@administration_required
|
|
#now forbidden,only used by SEI & PKU Staffs and students.
|
|
#can be used by admin for testing
|
|
def register():
|
|
return registerView.as_view()
|
|
|
|
|
|
|
|
@app.route("/activate/", methods=['GET', 'POST'])
|
|
@login_required
|
|
def activate():
|
|
return userActivateView.as_view()
|
|
|
|
@app.route("/dashboard/", methods=['GET'])
|
|
@login_required
|
|
def dashboard():
|
|
return dashboardView.as_view()
|
|
|
|
@app.route("/dashboard_guest/", methods=['GET'])
|
|
def dashboard_guest():
|
|
resp = make_response(dashboard_guestView.as_view())
|
|
resp.set_cookie('guest-cookie', cookie_tool.generate_cookie('guest', app.secret_key))
|
|
return resp
|
|
|
|
@app.route("/document/", methods=['GET'])
|
|
def redirect_dochome():
|
|
return redirect("http://docklet.unias.org/userguide")
|
|
|
|
@app.route("/config/", methods=['GET'])
|
|
@login_required
|
|
def config():
|
|
return configView.as_view()
|
|
|
|
|
|
@app.route("/workspace/create/", methods=['GET'])
|
|
@activated_required
|
|
def addCluster():
|
|
return addClusterView.as_view()
|
|
|
|
@app.route("/workspace/list/", methods=['GET'])
|
|
@login_required
|
|
def listCluster():
|
|
return listClusterView.as_view()
|
|
|
|
@app.route("/workspace/add/", methods=['POST'])
|
|
@login_required
|
|
def createCluster():
|
|
createClusterView.clustername = request.form["clusterName"]
|
|
createClusterView.image = request.form["image"]
|
|
return createClusterView.as_view()
|
|
|
|
@app.route("/workspace/scaleout/<clustername>/", methods=['POST'])
|
|
@login_required
|
|
def scaleout(clustername):
|
|
scaleoutView.image = request.form["image"]
|
|
scaleoutView.clustername = clustername
|
|
return scaleoutView.as_view()
|
|
|
|
@app.route("/workspace/scalein/<clustername>/<containername>/", methods=['GET'])
|
|
@login_required
|
|
def scalein(clustername,containername):
|
|
scaleinView.clustername = clustername
|
|
scaleinView.containername = containername
|
|
return scaleinView.as_view()
|
|
|
|
@app.route("/workspace/start/<clustername>/", methods=['GET'])
|
|
@login_required
|
|
def startClustet(clustername):
|
|
startClusterView.clustername = clustername
|
|
return startClusterView.as_view()
|
|
|
|
@app.route("/workspace/stop/<clustername>/", methods=['GET'])
|
|
@login_required
|
|
def stopClustet(clustername):
|
|
stopClusterView.clustername = clustername
|
|
return stopClusterView.as_view()
|
|
|
|
@app.route("/workspace/delete/<clustername>/", methods=['GET'])
|
|
@login_required
|
|
def deleteClustet(clustername):
|
|
deleteClusterView.clustername = clustername
|
|
return deleteClusterView.as_view()
|
|
|
|
@app.route("/workspace/detail/<clustername>/", methods=['GET'])
|
|
@login_required
|
|
def detailCluster(clustername):
|
|
detailClusterView.clustername = clustername
|
|
return detailClusterView.as_view()
|
|
|
|
@app.route("/workspace/flush/<clustername>/<containername>/", methods=['GET'])
|
|
@login_required
|
|
def flushCluster(clustername,containername):
|
|
flushClusterView.clustername = clustername
|
|
flushClusterView.containername = containername
|
|
return flushClusterView.as_view()
|
|
|
|
@app.route("/workspace/save/<clustername>/<containername>/", methods=['POST'])
|
|
@login_required
|
|
def saveImage(clustername,containername):
|
|
saveImageView.clustername = clustername
|
|
saveImageView.containername = containername
|
|
saveImageView.isforce = "false"
|
|
saveImageView.imagename = request.form['ImageName']
|
|
saveImageView.description = request.form['description']
|
|
return saveImageView.as_view()
|
|
|
|
@app.route("/workspace/save/<clustername>/<containername>/force/", methods=['POST'])
|
|
@login_required
|
|
def saveImage_force(clustername,containername):
|
|
saveImageView.clustername = clustername
|
|
saveImageView.containername = containername
|
|
saveImageView.isforce = "true"
|
|
saveImageView.imagename = request.form['ImageName']
|
|
saveImageView.description = request.form['description']
|
|
return saveImageView.as_view()
|
|
|
|
@app.route("/addproxy/<clustername>/", methods=['POST'])
|
|
@login_required
|
|
def addproxy(clustername):
|
|
addproxyView.clustername = clustername
|
|
addproxyView.ip = request.form['proxy_ip']
|
|
addproxyView.port = request.form['proxy_port']
|
|
return addproxyView.as_view()
|
|
|
|
@app.route("/deleteproxy/<clustername>/", methods=['GET'])
|
|
@login_required
|
|
def deleteproxy(clustername):
|
|
deleteproxyView.clustername = clustername
|
|
return deleteproxyView.as_view()
|
|
|
|
@app.route("/image/description/<image>/", methods=['GET'])
|
|
@login_required
|
|
def descriptionImage(image):
|
|
descriptionImageView.image = image
|
|
return descriptionImageView.as_view()
|
|
|
|
@app.route("/image/share/<image>/", methods=['GET'])
|
|
@login_required
|
|
def shareImage(image):
|
|
shareImageView.image = image
|
|
return shareImageView.as_view()
|
|
|
|
@app.route("/image/unshare/<image>/", methods=['GET'])
|
|
@login_required
|
|
def unshareImage(image):
|
|
unshareImageView.image = image
|
|
return unshareImageView.as_view()
|
|
|
|
@app.route("/image/delete/<image>/", methods=['GET'])
|
|
@login_required
|
|
def deleteImage(image):
|
|
deleteImageView.image = image
|
|
return deleteImageView.as_view()
|
|
|
|
@app.route("/hosts/", methods=['GET'])
|
|
@administration_required
|
|
def hosts():
|
|
return hostsView.as_view()
|
|
|
|
@app.route("/hosts/<com_ip>/", methods=['GET'])
|
|
@administration_required
|
|
def hostsRealtime(com_ip):
|
|
hostsRealtimeView.com_ip = com_ip
|
|
return hostsRealtimeView.as_view()
|
|
|
|
@app.route("/hosts/<com_ip>/containers/", methods=['GET'])
|
|
@administration_required
|
|
def hostsConAll(com_ip):
|
|
hostsConAllView.com_ip = com_ip
|
|
return hostsConAllView.as_view()
|
|
|
|
@app.route("/vclusters/", methods=['GET'])
|
|
@login_required
|
|
def status():
|
|
return statusView.as_view()
|
|
|
|
@app.route("/vclusters/<vcluster_name>/<node_name>/", methods=['GET'])
|
|
@login_required
|
|
def statusRealtime(vcluster_name,node_name):
|
|
statusRealtimeView.node_name = node_name
|
|
return statusRealtimeView.as_view()
|
|
|
|
@app.route("/monitor/hosts/<comid>/<infotype>", methods=['POST'])
|
|
@app.route("/monitor/vnodes/<comid>/<infotype>", methods=['POST'])
|
|
@login_required
|
|
def monitor_request(comid,infotype):
|
|
data = {
|
|
"user": session['username']
|
|
}
|
|
result = dockletRequest.post(request.path, data)
|
|
return json.dumps(result)
|
|
|
|
@app.route("/monitor/User/", methods=['GET'])
|
|
@administration_required
|
|
def monitorUserAll():
|
|
return monitorUserAllView.as_view()
|
|
|
|
|
|
|
|
|
|
@app.route("/user/list/", methods=['GET', 'POST'])
|
|
@administration_required
|
|
def userlist():
|
|
return userlistView.as_view()
|
|
|
|
@app.route("/group/list/", methods=['POST'])
|
|
@administration_required
|
|
def grouplist():
|
|
return grouplistView.as_view()
|
|
|
|
@app.route("/group/detail/", methods=['POST'])
|
|
@administration_required
|
|
def groupdetail():
|
|
return groupdetailView.as_view()
|
|
|
|
@app.route("/group/query/", methods=['POST'])
|
|
@administration_required
|
|
def groupquery():
|
|
return groupqueryView.as_view()
|
|
|
|
@app.route("/group/modify/", methods=['POST'])
|
|
@administration_required
|
|
def groupmodify():
|
|
return groupmodifyView.as_view()
|
|
|
|
@app.route("/user/data/", methods=['GET', 'POST'])
|
|
@administration_required
|
|
def userdata():
|
|
return userdataView.as_view()
|
|
|
|
@app.route("/user/add/", methods=['POST'])
|
|
@administration_required
|
|
def useradd():
|
|
return useraddView.as_view()
|
|
|
|
@app.route("/user/modify/", methods=['POST'])
|
|
@administration_required
|
|
def usermodify():
|
|
return usermodifyView.as_view()
|
|
|
|
@app.route("/group/add/", methods=['POST'])
|
|
@administration_required
|
|
def groupadd():
|
|
return groupaddView.as_view()
|
|
|
|
@app.route("/user/info/", methods=['GET', 'POST'])
|
|
@login_required
|
|
def userinfo():
|
|
return userinfoView.as_view()
|
|
|
|
@app.route("/user/query/", methods=['GET', 'POST'])
|
|
@administration_required
|
|
def userquery():
|
|
return userqueryView.as_view()
|
|
|
|
|
|
@app.route("/admin/", methods=['GET', 'POST'])
|
|
@administration_required
|
|
def adminpage():
|
|
return adminView.as_view()
|
|
|
|
@app.route('/index/', methods=['GET'])
|
|
def jupyter_control():
|
|
return redirect('/dashboard/')
|
|
|
|
# for download basefs.tar.bz
|
|
# remove, not the function of docklet
|
|
# should download it from a http server
|
|
#@app.route('/download/basefs', methods=['GET'])
|
|
#def download():
|
|
#fsdir = env.getenv("FS_PREFIX")
|
|
#return send_from_directory(fsdir+'/local', 'basefs.tar.bz', as_attachment=True)
|
|
|
|
# jupyter auth APIs
|
|
@app.route('/jupyter/', methods=['GET'])
|
|
def jupyter_prefix():
|
|
path = request.args.get('next')
|
|
if path == None:
|
|
return redirect('/login/')
|
|
return redirect('/login/'+'?next='+path)
|
|
|
|
@app.route('/jupyter/home/', methods=['GET'])
|
|
def jupyter_home():
|
|
return redirect('/dashboard/')
|
|
|
|
@app.route('/jupyter/login/', methods=['GET', 'POST'])
|
|
def jupyter_login():
|
|
return redirect('/login/')
|
|
|
|
@app.route('/jupyter/logout/', methods=['GET'])
|
|
def jupyter_logout():
|
|
return redirect('/logout/')
|
|
|
|
@app.route('/jupyter/authorizations/cookie/<cookie_name>/<cookie_content>/', methods=['GET'])
|
|
def jupyter_auth(cookie_name, cookie_content):
|
|
username = cookie_tool.parse_cookie(cookie_content, app.secret_key)
|
|
if username == None:
|
|
resp = make_response('cookie auth failed')
|
|
resp.status_code = 404
|
|
return resp
|
|
return json.dumps({'name': username})
|
|
|
|
@app.errorhandler(401)
|
|
def not_authorized(error):
|
|
if "username" in session:
|
|
return render_template('error/401.html', mysession = session)
|
|
else:
|
|
return redirect('/login/')
|
|
|
|
@app.errorhandler(500)
|
|
def internal_server_error(error):
|
|
if "username" in session:
|
|
return render_template('error/500.html', mysession = session)
|
|
else:
|
|
return redirect('/login/')
|
|
if __name__ == '__main__':
|
|
'''
|
|
to generate a secret_key
|
|
|
|
from base64 import b64encode
|
|
from os import urandom
|
|
|
|
secret_key = urandom(24)
|
|
secret_key = b64encode(secret_key).decode('utf-8')
|
|
|
|
'''
|
|
logger.info('Start Flask...:')
|
|
try:
|
|
secret_key_file = open(env.getenv('FS_PREFIX') + '/local/web_secret_key.txt')
|
|
app.secret_key = secret_key_file.read()
|
|
secret_key_file.close()
|
|
except:
|
|
from base64 import b64encode
|
|
from os import urandom
|
|
secret_key = urandom(24)
|
|
secret_key = b64encode(secret_key).decode('utf-8')
|
|
app.secret_key = secret_key
|
|
secret_key_file = open(env.getenv('FS_PREFIX') + '/local/web_secret_key.txt', 'w')
|
|
secret_key_file.write(secret_key)
|
|
secret_key_file.close()
|
|
|
|
os.environ['APP_KEY'] = app.secret_key
|
|
runcmd = sys.argv[0]
|
|
app.runpath = runcmd.rsplit('/', 1)[0]
|
|
|
|
webip = "0.0.0.0"
|
|
webport = env.getenv("WEB_PORT")
|
|
|
|
webViews.dockletrequest.endpoint = 'http://%s:%d' % (env.getenv('MASTER_IP'), env.getenv('MASTER_PORT'))
|
|
|
|
|
|
try:
|
|
opts, args = getopt.getopt(sys.argv[1:], "i:p:", ["ip=", "port="])
|
|
except getopt.GetoptError:
|
|
print ("%s -i ip -p port" % sys.argv[0])
|
|
sys.exit(2)
|
|
for opt, arg in opts:
|
|
if opt in ("-i", "--ip"):
|
|
webip = arg
|
|
elif opt in ("-p", "--port"):
|
|
webport = int(arg)
|
|
|
|
app.run(host = webip, port = webport, debug = True, threaded=True)
|