mirror of
https://github.com/yunionio/cloudpods.git
synced 2026-05-06 21:52:54 +08:00
294 lines
8.5 KiB
Python
Executable File
294 lines
8.5 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
|
|
import argparse
|
|
import os
|
|
from os.path import join as pjoin
|
|
import subprocess
|
|
import sys
|
|
|
|
|
|
def run_cmd(cmds):
|
|
print(' '.join(cmds))
|
|
proc = subprocess.Popen(
|
|
cmds, stdout=subprocess.PIPE)
|
|
while True:
|
|
line_gen = proc.stdout.readline().rstrip()
|
|
if not line_gen:
|
|
break
|
|
for l in line_gen:
|
|
print(l)
|
|
|
|
|
|
def run_generator(tool, input_dirs, out_pkg):
|
|
cmd = [tool]
|
|
for i in input_dirs:
|
|
cmd.extend(["--input-dirs", i])
|
|
cmd.extend(["--output-package", out_pkg])
|
|
run_cmd(cmd)
|
|
|
|
|
|
def run_model_api(input_dirs, out_pkg):
|
|
return run_generator('model-api-gen', input_dirs, out_pkg)
|
|
|
|
|
|
def run_swagger_gen(input_dirs, out_pkg):
|
|
return run_generator('swagger-gen', input_dirs, out_pkg)
|
|
|
|
|
|
def run_swagger_serve(output_dir, serve=False):
|
|
def is_swagger_yaml(file):
|
|
return file.endswith('.yaml') and file.startswith('swagger')
|
|
yamls = [pjoin(output_dir, x) for x in os.listdir(output_dir) if is_swagger_yaml(x)]
|
|
cmd = ['swagger-serve', 'generate']
|
|
cmd.extend(['-i', ','.join(yamls), '-o', output_dir])
|
|
if serve:
|
|
cmd.extend(['-p', "40900"])
|
|
cmd.append('--serve')
|
|
run_cmd(cmd)
|
|
|
|
|
|
def run_swagger_yaml(svc, swagger_pkg_dir, output_dir):
|
|
if not os.path.exists(output_dir):
|
|
os.makedirs(output_dir)
|
|
work_dir = pjoin(swagger_pkg_dir, svc)
|
|
cmd = ["swagger", "generate", "spec", "--scan-models"]
|
|
cmd.extend(["--work-dir", work_dir])
|
|
cmd.extend(["-o", pjoin(output_dir, "swagger_%s.yaml" % svc)])
|
|
run_cmd(cmd)
|
|
|
|
def remove_prefix(text, prefix):
|
|
return text[text.startswith(prefix) and len(prefix):]
|
|
|
|
class FuncDispatcher(object):
|
|
|
|
def __init__(self):
|
|
self.gen_dict = {}
|
|
self.collect_funcs()
|
|
|
|
def collect_funcs(self):
|
|
gen_dict = {}
|
|
for attr in dir(self):
|
|
if not attr.startswith('gen_'):
|
|
continue
|
|
func = getattr(self, attr)
|
|
if not callable(func):
|
|
continue
|
|
svc = remove_prefix(attr, 'gen_')
|
|
gen_dict[svc] = func
|
|
self.gen_dict = gen_dict
|
|
|
|
def get_choices(self):
|
|
svc = ["all"]
|
|
svc.extend(self.gen_dict.keys())
|
|
return svc
|
|
|
|
def dispatcher(self, opt):
|
|
def run_one(key):
|
|
self.gen_dict[key]()
|
|
def run_all():
|
|
for key in self.gen_dict:
|
|
run_one(key)
|
|
if opt.service is None or 'all' in opt.service:
|
|
run_all()
|
|
else:
|
|
for svc in opt.service:
|
|
run_one(svc)
|
|
|
|
def get_parser(self, subparsers, name, help):
|
|
parser = subparsers.add_parser(name, help=help)
|
|
parser.add_argument("-s", "--service", help="%s for services" % help,
|
|
nargs='+', choices=self.get_choices())
|
|
parser.set_defaults(func=self.dispatcher)
|
|
|
|
|
|
class ModelAPI(FuncDispatcher):
|
|
|
|
def __init__(self, pkg_dir, apis_dir):
|
|
super(ModelAPI, self).__init__()
|
|
self.pkg_dir = pkg_dir
|
|
self.apis_dir = apis_dir
|
|
|
|
def get_parser(self, subparsers):
|
|
return super(ModelAPI, self).get_parser(
|
|
subparsers, "model-api", "generate model struct code for api")
|
|
|
|
def run(self, pkg=[], out=[]):
|
|
if pkg is None:
|
|
return
|
|
in_dir = pjoin(self.pkg_dir, *pkg)
|
|
out_dir = pjoin(self.apis_dir, *out)
|
|
run_model_api([in_dir], out_dir)
|
|
|
|
def run_same(self, pkg):
|
|
self.run(pkg=[pkg], out=[pkg])
|
|
|
|
def run_model(self, svc):
|
|
self.run(pkg=[svc, "models"], out=[svc])
|
|
|
|
def gen_cloudcommon(self):
|
|
self.run(pkg=["cloudcommon", "db"])
|
|
self.run(pkg=["cloudcommon", "db", "proxy"], out=["cloudcommon", "proxy"])
|
|
run_swagger_gen(['yunion.io/x/cloudmux/pkg/cloudprovider'], 'yunion.io/x/onecloud/pkg/apis/cloudprovider')
|
|
self.run(pkg=["keystone", "models"], out=["identity"])
|
|
self.run_model("compute")
|
|
self.run(pkg=["compute", "models", "baremetal"], out=["compute", "baremetal"])
|
|
self.run_model("image")
|
|
self.run_model("cloudid")
|
|
self.run_model("notify")
|
|
self.run_model("cloudevent")
|
|
|
|
def gen_monitor(self):
|
|
self.run(pkg=["monitor", "models"], out=["monitor"])
|
|
|
|
def gen_yunionconf(self):
|
|
self.run(pkg=["yunionconf", "models"], out=["yunionconf"])
|
|
|
|
|
|
class SwaggerCode(FuncDispatcher):
|
|
|
|
def __init__(self, pkg_dir, pkg_swagger):
|
|
super(SwaggerCode, self).__init__()
|
|
self.pkg_dir = pkg_dir
|
|
self.pkg_swagger = pkg_swagger
|
|
|
|
def get_parser(self, subparsers):
|
|
return super(SwaggerCode, self).get_parser(
|
|
subparsers, "swagger-code", "generate swagger code")
|
|
|
|
def run(self, svc, pkg=[], out=''):
|
|
if svc is None:
|
|
return
|
|
if pkg is None:
|
|
return
|
|
svc_pkg_dir = pjoin(self.pkg_dir, svc)
|
|
input_dirs = [pjoin(svc_pkg_dir, x) for x in pkg]
|
|
out_dir = pjoin(self.pkg_swagger, out)
|
|
run_swagger_gen(input_dirs, out_dir)
|
|
|
|
def run_svc(self, svc, pkg=[]):
|
|
self.run(svc, pkg=pkg, out=svc)
|
|
|
|
def gen_identity(self):
|
|
self.run("keystone", pkg=["tokens", "models"], out="identity")
|
|
|
|
def gen_compute(self):
|
|
self.run("compute", pkg=["models"], out="compute")
|
|
|
|
def gen_image(self):
|
|
self.run("image", pkg=["models"], out="image")
|
|
|
|
def gen_cloudid(self):
|
|
self.run("cloudid", pkg=["models"], out="cloudid")
|
|
|
|
def gen_monitor(self):
|
|
self.run("monitor", pkg=["models"], out="monitor")
|
|
|
|
def gen_yunionconf(self):
|
|
self.run("yunionconf", pkg=["models"], out="yunionconf")
|
|
|
|
def gen_notify(self):
|
|
self.run("notify", pkg=["models"], out="notify")
|
|
|
|
def gen_cloudevent(self):
|
|
self.run("cloudevent", pkg=["models"], out="cloudevent")
|
|
|
|
|
|
|
|
class SwaggerYAML(FuncDispatcher):
|
|
|
|
def __init__(self, swagger_dir, out_dir):
|
|
super(SwaggerYAML, self).__init__()
|
|
self.swagger_dir = swagger_dir
|
|
self.out_dir = out_dir
|
|
|
|
def get_parser(self, subparsers):
|
|
return super(SwaggerYAML, self).get_parser(
|
|
subparsers, "swagger-yaml", "generate swagger yaml")
|
|
|
|
def run(self, svc):
|
|
run_swagger_yaml(svc, self.swagger_dir, self.out_dir)
|
|
|
|
def gen_identity(self):
|
|
self.run("identity")
|
|
|
|
def gen_compute(self):
|
|
self.run("compute")
|
|
|
|
def gen_image(self):
|
|
self.run("image")
|
|
|
|
def gen_cloudid(self):
|
|
self.run("cloudid")
|
|
|
|
def gen_monitor(self):
|
|
self.run("monitor")
|
|
|
|
def gen_yunionconf(self):
|
|
self.run("yunionconf")
|
|
|
|
def gen_notify(self):
|
|
self.run("notify")
|
|
|
|
def gen_cloudevent(self):
|
|
self.run("cloudevent")
|
|
|
|
class SwaggerServe(object):
|
|
|
|
def __init__(self, output_dir):
|
|
self.output_dir = output_dir
|
|
|
|
def get_parser(self, subparsers):
|
|
parser = subparsers.add_parser(
|
|
"swagger-serve", help="generate swagger web site and serve")
|
|
parser.set_defaults(func=self.run)
|
|
|
|
def run(self, opt):
|
|
run_swagger_serve(self.output_dir, serve=True)
|
|
|
|
|
|
class SwaggerSite(object):
|
|
|
|
def __init__(self, output_dir):
|
|
self.output_dir = output_dir
|
|
|
|
def get_parser(self, subparsers):
|
|
parser = subparsers.add_parser(
|
|
"swagger-site", help="generate swagger web site")
|
|
parser.set_defaults(func=self.run)
|
|
|
|
def run(self, opt):
|
|
run_swagger_serve(self.output_dir)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
ONECLOUD="yunion.io/x/onecloud"
|
|
PKG_ONECLOUD=pjoin(ONECLOUD, "pkg")
|
|
PKG_APIS=pjoin(PKG_ONECLOUD, "apis")
|
|
PKG_GENERATED=pjoin(PKG_ONECLOUD, "generated")
|
|
PKG_SWAGGER=pjoin(PKG_GENERATED, "swagger")
|
|
SCRIPTS_DIR=os.path.dirname(os.path.realpath(__file__))
|
|
CUR_DIR=os.path.dirname(SCRIPTS_DIR)
|
|
SWAGGER_PKG=pjoin(CUR_DIR, "pkg", "generated", "swagger")
|
|
OUTPUT_DIR=pjoin(CUR_DIR, "_output")
|
|
OUTPUT_SWAGGER_DIR=pjoin(OUTPUT_DIR, "swagger")
|
|
|
|
model_api = ModelAPI(PKG_ONECLOUD, PKG_APIS)
|
|
swagger_yaml = SwaggerYAML(SWAGGER_PKG, OUTPUT_SWAGGER_DIR)
|
|
swagger_code = SwaggerCode(PKG_ONECLOUD, PKG_SWAGGER)
|
|
swagger_serve = SwaggerServe(OUTPUT_SWAGGER_DIR)
|
|
swagger_site = SwaggerSite(OUTPUT_SWAGGER_DIR)
|
|
|
|
parser = argparse.ArgumentParser(description="Code generate helper.")
|
|
subparsers = parser.add_subparsers(dest='cmd')
|
|
subparsers.required = True
|
|
|
|
for cmd in [model_api, swagger_code, swagger_yaml, swagger_serve, swagger_site]:
|
|
cmd.get_parser(subparsers)
|
|
|
|
if len(sys.argv) == 1:
|
|
parser.print_help()
|
|
sys.exit(1)
|
|
|
|
options = parser.parse_args()
|
|
options.func(options)
|