def docker_run(sid: uuid.UUID):
if request.method != "POST":
return json_result(-1, "POST only")
sid = str(sid)
tag = request.form["tag"]
sshport = int(request.form["sshport"])
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.images
image: Image = deserialize_json(Image,
db.find_one({
"uid": uid,
"uuid": sid
}))
if not image:
return json_result(-1, "Docker::Images::rmi failed")
container_id = DockerImageAPI.run(tag, "",
sshport) # image.run(tag, port=sshport)
container_uuid = str(uuid.uuid4())
container = Container(uid, tag, "start", sid, sshport, container_id,
container_uuid)
db: wrappers.Collection = mongo.db.containers
db.insert_one(container.__dict__)
DockerContainerAPI.start(container)
docker_daemon.notify(container_id)
return json_result(0, "Successfully run")
def api_request_auth():
username = request.form["username"]
password = request.form["password"]
result = authapi.signin(username, password)
if result == "":
return json_result(-1, "login failed")
return json_result(0, result)
def api_image_run(sid: uuid.UUID, port: int):
user: User = xtoken_user(AuthAPI.getXToken())
tag = randomString(15)
db: wrappers.Collection = mongo.db.images
image: Image = deserialize_json(
Image, db.find_one({
"uid": user.uuid,
"uuid": str(sid)
}))
try:
container_id = DockerImageAPI.run(image.tag, "", port)
container_uuid = str(uuid.uuid4())
container = Container(user.uuid, tag, "start", str(sid), port,
container_id, container_uuid)
db: wrappers.Collection = mongo.db.containers
db.insert_one(container.__dict__)
DockerContainerAPI.start(container)
docker_daemon.notify(container_id)
return json_result(0, "image run")
except:
return json_result(-1, "image not found")
def docker_rm(sid: uuid.UUID):
sid = str(sid)
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.containers
container: Container = deserialize_json(
Container, db.find_one({
"uid": uid,
"uuid": sid
}))
if not container:
return render_template("fail.html")
status = container.status
container.status = "removing"
db.update({"uid": uid, "uuid": sid}, container.__dict__)
try:
DockerContainerAPI.remove(container)
docker_daemon.notify_remove(container.short_id)
except:
container.status = status
db.update({"uid": uid, "uuid": sid}, container.__dict__)
return json_result(-1, "Docker::Container::remove failed")
return json_result(0, "Successfully container removed")
def docker_rmi(sid: uuid.UUID):
"""
:param uid: user uuid
:param sid: image uuid
"""
sid = str(sid)
uid: uuid.UUID = session.get("uuid")
db: wrappers.Collection = mongo.db.images
image: Image = deserialize_json(Image,
db.find_one({
"uid": uid,
"uuid": sid
}))
if not image:
return json_result(-1, "Docker::Images::rmi failed")
ct: wrappers.Collection = mongo.db.containers
containers: list = deserialize_json(Container, ct.find({"image": sid}))
for item in containers:
container: Container = item
status = docker_status(container.uuid)
if status != "stop":
return json_result(
-1, "Docker::Images::rmi failed(container is alive)")
# delete image
DockerImageAPI.delete(image.tag)
return json_result(0, "Successfully image removed")
def api_images():
user = xtoken_user(AuthAPI.getXToken())
img_db: wrappers.Collection = mongo.db.images
image: list = deserialize_json(Image, img_db.find({"uid": user.uuid}))
if len(image) == 0:
return json_result(-1, "image not found")
return json_result(0, image)
def cp(self, src, dst):
if "../" in src or "../" in dst:
return json_result(-1, "invalid path")
if not os.path.exists(src):
return json_result(-1, "invalid path")
shutil.copy(src, dst)
return json_result(0, "success")
def admin_users_setlevel(sid: uuid.UUID, level: int):
if level not in User.LEVELS:
return json_result(-1, "invalid level")
user: User = user_api.find_by_uuid(sid)
user.level = level
user_api.update_by_uuid(sid, user)
return json_result(0, "success")
def api_containers():
user = xtoken_user(AuthAPI.getXToken())
con_db: wrappers.Collection = mongo.db.containers
container: list = deserialize_json(Container,
con_db.find({"uid": user.uuid}))
if len(container) == 0:
return json_result(-1, "container not found")
return json_result(0, container)
def rmdir(self, username, path):
path = self.base + username + "/" + path
if "../" in path:
return json_result(-1, "invalid path")
if not os.path.exists(path):
return json_result(-1, "path not exist")
os.removedirs(path)
return json_result(0, "success")
def admin_images_remove(tag: str):
idx = tag.rfind("-")
tag = tag[:idx] + ":" + tag[idx + 1:]
image: Image = docker_api.image.find_by_tag(tag)
if image == None:
return json_result(-1, "image not exists")
docker_api.image.delete(image.tag)
return json_result(0, "success")
def rm(self, path):
if "../" in path:
return json_result(-1, "invalid path")
if not os.path.exists(path):
return json_result(-1, "file not exist")
if not os.path.isfile(path):
return json_result(-1, "invalid type")
os.remove(path)
return json_result(0, "success")
def userfile_upload():
uid = session.get("uuid")
username = session.get("username")
path = request.form["path"]
if "../" in path:
return json_result(-1, "invalid path")
f = request.files["file"]
fn = userfile_base + username + "/" + path + "/" + f.filename
f.save(fn)
return json_result(0, "success")
def api_image_rm(sid):
user: User = xtoken_user(AuthAPI.getXToken())
db: wrappers.Collection = mongo.db.images
image: Image = deserialize_json(
Image, db.find_one({
"uid": user.uuid,
"uuid": str(sid)
}))
try:
DockerImageAPI.delete(image.tag)
return json_result(0, "image removed")
except:
return json_result(-1, "image not found")
def api_container_rm(sid):
user: User = xtoken_user(AuthAPI.getXToken())
db: wrappers.Collection = mongo.db.containers
container: Container = deserialize_json(
Container, db.find_one({
"uid": user.uuid,
"uuid": str(sid)
}))
try:
DockerContainerAPI.remove(container)
return json_result(0, "container removed")
except:
return json_result(-1, "container not found")
def admin_users_add():
username = request.form["username"]
password = request.form["password"]
level = int(request.form["level"])
if "../" in username:
return json_result(0, "invalid username")
result = user_api.find_by_name(username)
if result != None:
return json_result(-1, "exist user")
u_uuid = user_api.add(username, password, level)
return json_result(0, u_uuid)
def read(self, username, path):
rpath = self.base + username + "/" + path
if not os.path.exists(rpath):
return False
with open(rpath, "rb") as f:
result = f.read()
return json_result(0, base64.b64encode(result).decode())
def purchase(self, paypal: Paypal, amount: int):
if amount <= 0:
return json_result(-1, "invalid amount")
db: wrappers.Collection = mongo.db.paypal
db.insert_one(paypal.__dict__)
cdb: wrappers.Collection = mongo.db.credit
result = cdb.find_one({"username": session["username"]})
if not result:
result = {"username": session["username"], "credit": 0}
cdb.insert_one(result)
result["credit"] += amount
cdb.update({"username": session["username"]}, result)
return json_result(0, "success")
def write(self, username, path, data):
rpath = self.base + username + "/" + path
if not os.path.exists(rpath):
return False
f = open(rpath, "wb")
f.write(data)
f.close()
return json_result(0, "success")
def api_image_detail(sid: uuid.UUID):
user: User = xtoken_user(AuthAPI.getXToken())
db: wrappers.Collection = mongo.db.images
image: Image = deserialize_json(
Image, db.find_one({
"uid": user.uuid,
"uuid": str(sid)
}))
return json_result(0, image)
def api_container_detail(sid: uuid.UUID):
user: User = xtoken_user(AuthAPI.getXToken())
db: wrappers.Collection = mongo.db.images
container: Container = deserialize_json(
Container, db.find_one({
"uid": user.uuid,
"uuid": str(sid)
}))
return json_result(0, container)
def admin_users_update(sid: uuid.UUID):
password = request.form["password"]
level = request.form["level"]
user: User = user_api.find_by_uuid(sid)
if user == None:
return json_result(-1, "user not found")
user.password = password
try:
user.level = int(level)
except:
return json_result(-1, "level is not integer")
if user.level not in User.LEVELS:
return json_result(-1, "invalid level")
user_api.update_by_uuid(sid, user)
return json_result(0, "success")
def docker_stop(sid: uuid.UUID):
sid = str(sid)
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.containers
container: Container = deserialize_json(
Container, db.find_one({
"uid": uid,
"uuid": sid
}))
if not container:
return json_result(-1, "container not found")
# container stop & check
try:
DockerContainerAPI.stop(container)
except:
return json_result(-1, "Docker::Container::stop failed")
return json_result(0, "container stop")
def docker_start(sid: uuid.UUID):
sid = str(sid)
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.containers
container: Container = deserialize_json(
Container, db.find_one({
"uid": uid,
"uuid": sid
}))
if not container:
return json_result(-1, "container not found")
# container start & check
try:
DockerContainerAPI.start(container)
return json_result(0, "container start")
except:
container.status = "failed"
db.update({"uid": uid, "uuid": sid}, container.__dict__)
return json_result(-1, "Docker::Container::start failed")
def listing(self, username, path):
result = {
"is_base": True,
"path": "/file/" + path,
"dir": [],
"file": []
}
for f in glob.glob(self.base + username + "/" + path + "/*"):
if os.path.isdir(f):
result["dir"] += [os.path.basename(f)]
else:
result["file"] += [os.path.basename(f)]
return json_result(0, result)
def docker_images_search():
tag = request.form["tag"]
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.images
result: list = deserialize_json(
Image, db.find({
"uid": uid,
"tag": {
"$regex": tag
}
}))
r = []
for image in result:
r += [image.__dict__]
return json_result(0, r)
def docker_containers_search():
tag = request.form["tag"]
uid = session.get("uuid")
db: wrappers.Collection = mongo.db.containers
result: list = deserialize_json(
Container, db.find({
"uid": uid,
"tag": {
"$regex": tag
}
}))
r = []
for container in result:
r += [container.__dict__]
return json_result(0, result)
def docker_build():
"""
GET
:param uid: user uuid
POST
:param tag: docker tag
:parma dockfile: dockerfile uuid
:param rootpass: root password for ssh
:param sshport: ssh port forwarding
build Dockerfile
"""
if request.method != "POST":
return json_result(-1, "POST only")
uid = session.get("uuid")
username = session.get("username")
tag = request.form["tag"]
dockfile = request.form["dockfile"]
rootpass = request.form["rootpass"]
sshport = int(request.form["sshport"])
fn = "upload/{}/{}/Dockerfile".format(username, dockfile)
with open(fn, "r") as f:
df = f.read()
name = tag.split(":")[0]
ver = "latest"
if len(tag.split(":")) == 1:
ver = tag.split(":")[1]
tag = randomString(20 - len(name)) + name + ":" + ver
image_uuid = str(uuid.uuid4())
container_uuid = str(uuid.uuid4())
image = Image(uid, "", tag, "installing", sshport, "", image_uuid)
db: wrappers.Collection = mongo.db.images
db.insert_one(image.__dict__)
# search Dockerfile
df: wrappers.Collection = mongo.db.dockerfile
result: Dockerfile = deserialize_json(Dockerfile,
df.find_one({"uuid": dockfile}))
if result == None:
return json_result(-1, "Dockerfile is not exist")
try:
# image build
image.status = "build"
db.update({"uuid": image_uuid}, image.__dict__)
result, imgs = DockerImageAPI.build(result.path, rootpass, tag)
image.short_id = imgs[0]["Id"].split(":")[1]
print(result)
image.status = "done"
db.update({"uuid": image_uuid}, image.__dict__)
except:
image.status = "fail"
db.update({"uuid": image_uuid}, image.__dict__)
return json_result(-1, "Dockerfile::Image::build fail")
# container start
container_id = DockerImageAPI.run(tag, "",
sshport) # image.run(tag, port=sshport)
container = Container(uid, tag, "start", image_uuid, sshport, container_id,
container_uuid)
container.start(container_id)
db: wrappers.Collection = mongo.db.containers
db.insert_one(container.__dict__)
docker_daemon.notify(container_id)
result_stream = []
for item in result:
try:
result_stream += [item["stream"]]
except:
continue
return json_result(0, "".join(result_stream))
def history(self, username):
db: wrappers.Collection = mongo.db.paypal
return json_result(0, db.find({"username": username}))
def api_error():
return json_result(-1, "error")
