def op_table():
commands_man = args_man.add_subparsers(title="Commands",
description=None,
metavar="COMMAND OPTIONS",
dest="sub_cmd")
create_man = commands_man.add_parser("create", help=g_help("create"))
create_man.add_argument("-c",
metavar="path",
dest="conf_path",
help=g_help("conf_path"))
create_man.add_argument("-d",
metavar="path",
dest="directory",
help=g_help("dir"))
create_man.add_argument("--file-prefix",
metavar="path",
dest="file_prefix",
help=g_help("file_prefix"))
create_man.add_argument("-f",
metavar="path",
dest="files",
help=g_help("file"),
nargs="*",
default=[])
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = args_man.parse_args()
if args.sub_cmd == "create":
create_table(args)
def cli_main():
parser = argparse.ArgumentParser()
parser.add_argument("-a",
"--action",
dest="action",
help=g_help("action"),
choices=["reset", "block", "unlock", "genetic", "new"])
parser.add_argument("-u", "--user", dest="user", help=g_help("user"))
parser.add_argument("-p",
"--password",
dest="password",
help=g_help("new_password"),
default="123456")
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = parser.parse_args()
if args.action is None:
error_and_exit("Please Set [action] use -a or --action", 1)
if args.user is None:
error_and_exit("Please Set [user] use -u or --user", 2)
if args.action == "reset":
reset_password(args.user, args.password)
elif args.action == "block":
block_user(args.user)
elif args.action == "unlock":
unlock_user(args.user)
elif args.action == "genetic":
grant_genetic(args.user)
elif args.action == "new":
new_user(args.user, args.password)
def get_key(endpoint, app, filters):
params = dict(app=app)
for item in filters:
s = item.split("=", 1)
if len(s) != 2:
error_and_exit(g_help("error_filter", item))
params[s[0]] = s[1]
try:
resp = requests.get(endpoint, params=params, headers=headers)
if resp.status_code != 200:
error_and_exit(g_help("error_get", resp.status_code))
r_data = resp.json()
if r_data["status"] is False:
error_and_exit(r_data["data"])
data = r_data["data"]
for key in data.keys():
if key[0] == "_":
data[key[1:]] = data[key]
del data[key]
except requests.RequestException as re:
error_and_exit(g_help("error_get", str(re)))
return
except ValueError as ve:
error_and_exit(g_help("error_get", str(ve)))
return
except KeyError as ke:
error_and_exit(g_help("error_get", str(ke)))
return
return data
def find_one_port():
args_man.add_argument("-s",
"--server",
dest="server",
help=g_help("server"),
choices=define_server.keys())
args_man.add_argument("-p",
"--ports",
dest="ports",
help=g_help("port"),
nargs="*")
args = args_man.parse_args()
all_ports = []
if args.server is not None:
all_ports.extend(define_server[args.server])
if args.ports is not None:
for port in args.ports:
ports = re.split(r"\D", port)
ports = map(lambda x: int(x), filter(lambda x: len(x) > 0, ports))
all_ports.extend(ports)
for item in all_ports:
logger.debug("check is listen %s" % item)
if is_listen(item) is False:
logger.info(item)
sys.exit(0)
sys.exit(1)
def read_conf():
arg_man.add_argument("-c",
"--conf-path",
dest="conf_path",
help=g_help("conf_file"),
metavar="conf_path",
required=True)
arg_man.add_argument("-i",
"--ignore-error",
dest="ignore_error",
help=g_help("ignore_error"),
action='store_true',
default=False)
arg_man.add_argument("-s",
"--section",
dest="section",
help=g_help("section"),
metavar="section",
required=True)
arg_man.add_argument("option",
metavar="option",
nargs="*",
help=g_help("option"))
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = arg_man.parse_args()
values = read(args.conf_path,
args.section,
args.option,
ignore=args.ignore_error)
for v in values:
print(v)
def read(conf_path, section, options, ignore=False):
if os.path.exists(conf_path) is False:
msg = g_help("file_not_exist", conf_path)
if ignore is True:
logger.warning(msg)
return map(lambda x: "", options)
error_and_exit(msg)
config = ConfigParser.ConfigParser()
config.read(conf_path)
if config.has_section(section) is False:
msg = g_help("section_not_found", section)
if ignore is True:
logger.warning(msg)
return map(lambda x: "", options)
error_and_exit(msg)
values = []
for option in options:
if config.has_option(section, option) is False:
msg = g_help("option_not_found", option)
if ignore is True:
logger.warning(msg)
values.append("")
continue
error_and_exit(msg)
values.append(config.get(section, option))
return values
def create_table(args):
if args.conf_path is None:
args.conf_path = get_environ("DB_CONF_PATH")
t = TableDB(conf_path=args.conf_path)
suffix_comp = re.compile(r"\w+\.(json|function|procedure|trigger|view)$",
re.I)
all_files = args.files
if args.file_prefix is not None:
all_files = map(lambda x: args.file_prefix + x, all_files)
if args.directory is not None:
desc_files = os.listdir(args.directory)
all_files.extend(
map(lambda x: os.path.join(args.directory, x), desc_files))
for file_path in all_files:
filename = os.path.split(file_path)[1]
if suffix_comp.match(filename) is None:
logger.warning(g_help("skip_file", file_path))
continue
logger.info(g_help("handle_file", file_path))
check_file_exist(file_path)
if file_path.endswith(".json"):
r = t.create_from_json_file(file_path)
else:
with open(file_path) as rf:
c = rf.read()
ds = re.findall(r"(DROP[\s\S]+? IF EXISTS[\s\S]+?(;|\n))", c,
re.I)
for item in ds:
t.execute(item[0])
fs = re.findall(r"(CREATE[\s\S]+?(END;|END\n|$))", c)
for item in fs:
t.execute(item[0])
def set_conf():
source_local()
conf_dir = os.environ.get("JINGD_CONF_DIR")
if conf_dir is None:
error_and_exit(g_help("defect_env", "JINGD_CONF_DIR"))
conf_path = os.path.join(conf_dir, "supervisord.conf")
if os.path.exists(conf_path) is False:
error_and_exit(g_help("file_lost"))
sys.argv.insert(1, "-c")
sys.argv.insert(2, conf_path)
def cli_main():
parser = argparse.ArgumentParser()
parser.add_argument("-a", "--account", dest="account", help=g_help("user"))
parser.add_argument("sample_no", help=g_help("sample_no"))
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = parser.parse_args()
sample_no = int(args.sample_no)
re_run(sample_no, args.account)
def multi_download():
args_man.add_argument("--allow-custom", dest="allow_custom", help=g_help("allow_custom"), action="store_true", default=False)
args_man.add_argument("-d", "--oss-dir", dest="oss_dir", help=g_help("oss_dir"), metavar="", default="")
args_man.add_argument("-e", "--endpoint", dest="endpoint", help=g_help("endpoint"), metavar="",
default=default_endpoint)
args_man.add_argument("-n", "--name", dest="name", metavar="filename", help=g_help("name"))
args_man.add_argument("-f", "--force", action="store_true", help=g_help("force"), default=False)
args_man.add_argument("files", metavar="oss_file", nargs="*", help=g_help("oss_file"))
add_output()
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = args_man.parse_args()
allow_custom = args.allow_custom
if allow_custom is True:
jingd_env = get_environ("JINGD_ENV", "")
if jingd_env == "":
logger.warning(g_help("empty_env"))
else:
jingd_env = ""
f_inputs = args.files
out_dir = args.output
if out_dir is None:
out_dir = "."
if len(f_inputs) == 1:
name = args.name if args.name is not None else f_inputs[0]
save_path = os.path.join(out_dir, name)
e_code = download_action(args.endpoint, args.oss_dir, f_inputs[0], save_path, force=args.force)
if e_code != 0:
error_and_exit(g_help("error", f_inputs[0]))
else:
for item in f_inputs:
save_path = os.path.join(out_dir, item)
e_code = download_action(args.endpoint, args.oss_dir, item, save_path, force=args.force, custom_dir=jingd_env)
if e_code != 0:
error_and_exit(g_help("error", item))
def write_conf(args):
if len(sys.argv) <= 1:
sys.argv.append("-h")
service_name = args.name
service_item = dict(image=args.image, container_name=service_name)
g_volumes = set()
if args.volumes is not None:
for volume in args.volumes:
volume_p = volume.split(":")
if re.match("^[a-zA-Z0-9][a-zA-Z0-9_.-]*$", volume_p[0]):
g_volumes.add(volume_p[0])
service_item["volumes"] = args.volumes
if args.ports is not None:
service_item["ports"] = args.ports
for port in args.ports:
port_p = port.split(":")
if port_p[0] != port_p[1]:
break
else:
service_item["network_mode"] = "host"
del service_item["ports"]
if args.restart is not None:
service_item["restart"] = args.restart
if args.command is not None:
service_item["command"] = " ".join(args.command)
if args.environments is not None:
service_item["environment"] = args.environments
if args.working_dir is not None:
service_item["working_dir"] = args.working_dir
file_path = get_file(args.compose_dir)
if os.path.exists(file_path) is False:
logger.debug(g_help("create", file_path))
o_y = dict(version='2.4', services={service_name: service_item})
if len(g_volumes) > 0:
o_y["volumes"] = dict()
for key in g_volumes:
o_y["volumes"][key] = dict(name=key)
else:
f = open(file_path)
o_y = yaml.load(f)
o_y["version"] = "2.4"
if service_name in o_y["services"]:
logger.debug(g_help("exist_service"))
o_y["services"][service_name] = service_item
if len(g_volumes) > 0:
if "volumes" not in o_y:
o_y["volumes"] = dict()
for key in g_volumes:
o_y["volumes"][key] = dict(name=key)
w_f = open(file_path, "w")
yaml.dump(o_y, stream=w_f, default_flow_style=False)
def rewrite_conf(file_path, mode):
if os.path.exists(file_path) is False:
msg = g_help("file_not_exist", file_path)
error_and_exit(msg)
try:
with open(file_path) as rf:
c = rf.read()
except IOError:
error_and_exit(g_help("read_error", file_path))
return
if mode == 2:
n_c = c % os.environ
else:
n_c = c.format(**os.environ)
with open(file_path, "w") as w:
w.write(n_c)
def load_json(file_path):
if os.path.exists(file_path) is False:
msg = g_help("file_not_exist", file_path)
error_and_exit(msg)
try:
with open(file_path) as rf:
c = rf.read()
except IOError:
error_and_exit(g_help("read_error", file_path))
return
try:
o = json.loads(c)
return o
except ValueError:
error_and_exit(g_help("content_error", file_path))
return
def link():
args_man.add_argument("-c",
metavar="path",
dest="conf_path",
help=g_help("conf_path"))
args_man.add_argument("-r",
"--readonly",
dest="readonly",
action="store_true",
help=g_help("readonly"),
default=False)
args = args_man.parse_args()
if args.conf_path is None:
args.conf_path = get_environ("DB_CONF_PATH")
t = DB(conf_path=args.conf_path, readonly=args.readonly)
t.link()
def replace_file(file_path, value_dict):
if file_path is None:
return
if os.path.exists(file_path) is False:
msg = g_help("file_not_exist", file_path)
error_and_exit(msg)
try:
with open(file_path) as rf:
c = rf.read()
except IOError:
error_and_exit(g_help("read_error", file_path))
return
c2 = c % value_dict
try:
with open(file_path, "w") as wf:
wf.write(c2)
except IOError:
error_and_exit(g_help("write_error", file_path))
return
def download_action(endpoint, oss_dir, oss_item, save_path, force=False, custom_dir=""):
if os.path.exists(save_path) is True and force is False:
logger.warning(g_help("exist", oss_item))
return 0
logger.info(g_help("download", oss_item, save_path))
custom_url = ""
if custom_dir != "":
custom_url = get_download_url(endpoint, oss_item, oss_dir, custom_dir)
code = head_url(custom_url)
if code != 200:
logger.debug(g_help("head_error", custom_url, code))
custom_url = ""
if custom_url == "":
url = get_download_url(endpoint, oss_item, oss_dir)
code = head_url(url)
if code != 200:
error_and_exit(g_help("head_error", url, code))
else:
url = custom_url
cmd = ["curl", "-o", save_path, url]
e_code = os.system(" ".join(cmd))
return e_code
def environ_format():
arg_man.add_argument("-d",
"--directory",
dest="directory",
help=g_help("directory"),
metavar="directory")
arg_man.add_argument("-p",
"--prefix",
dest="prefix",
help=g_help("prefix"),
metavar="prefix")
arg_man.add_argument("-e",
"--end",
dest="end",
help=g_help("end"),
metavar="end")
arg_man.add_argument("-f",
"--filter",
dest="filter",
help=g_help("filter"),
metavar="filter",
default=r"\S*")
arg_man.add_argument("-i",
"-I",
"--input",
dest="input",
help=g_help("conf_file"),
metavar="conf_file",
action="append",
default=[])
arg_man.add_argument("inputs",
metavar="conf_file",
nargs="*",
help=g_help("conf_file"))
arg_man.add_argument("-m",
"--mode",
dest="mode",
help=g_help("mode"),
type=int,
choices=[1, 2],
default=1)
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = arg_man.parse_args()
files = args.input
files.extend(args.inputs)
if args.directory is not None:
files.extend(
list_files(args.directory, args.prefix, args.end, args.filter))
for item in files:
logger.info("format %s" % item)
rewrite_conf(item, args.mode)
logger.info("format %s success\n" % item)
def request_api(method, url, data):
api_endpoint = os.environ.get("JINGD_API_ENDPOINT")
if api_endpoint is None:
error_and_exit(g_help("defect_env", "JINGD_API_ENDPOINT"), -1)
headers = {"Content-Type": "application/json", "User-Agent": user_agent}
url = "%s%s" % (api_endpoint, url)
resp = requests.request(method, url, headers=headers, json=data)
if resp.status_code != 200:
error_and_exit(resp.status_code)
r_data = resp.json()
if r_data["status"] % 10000 < 100:
print(r_data["message"])
else:
error_and_exit(r_data["message"])
def json_update():
arg_man.add_argument("-c",
"-C",
dest="cover",
help=g_help("cover"),
action="store_true",
default=False)
arg_man.add_argument("-i",
"-I",
"--input",
dest="input",
help=g_help("json_file"),
metavar="json_file")
arg_man.add_argument("inputs",
metavar="json_file",
nargs="?",
help=g_help("json_file"))
add_output()
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = arg_man.parse_args()
o = load_json(args.input)
pass
def non_key():
arg_man.add_argument("-d", "--oss-dir", dest="oss_dir", help=g_help("oss_dir"), metavar="", default="ssh-key")
arg_man.add_argument("-e", "--endpoint", dest="endpoint", help=g_help("endpoint"), metavar="",
default=default_endpoint)
save_dir = os.path.join(os.environ.get("HOME"), ".ssh")
os.system("mkdir -p %s" % save_dir)
os.system("chmod 700 %s" % save_dir)
jingd_env = os.environ.get("JINGD_ENV", "")
args = arg_man.parse_args()
code, content = download_ssh_key(args.endpoint, "id_rsa", args.oss_dir, jingd_env)
code_pub, content_pub = download_ssh_key(args.endpoint, "id_rsa.pub", args.oss_dir, jingd_env)
if code != 200 or code_pub != 200:
if jingd_env == "":
msg = "id_rsa: %s\nid_ras.pub: %s" % (code, code_pub)
error_and_exit(msg)
code, content = download_ssh_key(args.endpoint, "id_rsa", args.oss_dir)
code_pub, content_pub = download_ssh_key(args.endpoint, "id_rsa.pub", args.oss_dir)
if code != 200 or code_pub != 200:
msg = "id_rsa: %s\nid_ras.pub: %s" % (code, code_pub)
error_and_exit(msg)
write_file(save_dir, "id_rsa", content)
write_file(save_dir, "id_rsa.pub", content_pub)
write_authorized_keys(save_dir, content_pub)
def json_merge():
arg_man.add_argument("-i",
"-I",
"--input",
dest="input",
help=g_help("json_file"),
action="append",
metavar="json_file",
default=[])
arg_man.add_argument("inputs",
metavar="json_file",
nargs="*",
help=g_help("json_file"))
add_output()
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = arg_man.parse_args()
f_inputs = args.inputs
f_inputs.extend(args.input)
o = dict()
for f in f_inputs:
f_o = load_json(f)
o.update(f_o)
json_output(o, args.output)
def request_jingd(service, method, url, data):
endpoint_env = "JINGD_%s_ENDPOINT" % service.upper()
auth_endpoint = os.environ.get(endpoint_env)
if auth_endpoint is None:
error_and_exit(g_help("defect_env", endpoint_env), -1)
headers = {"Content-Type": "application/json", "User-Agent": user_agent}
url = "%s%s" % (auth_endpoint, url)
if method == "GET":
resp = requests.request(method, url, headers=headers, params=data)
else:
resp = requests.request(method, url, headers=headers, json=data)
if resp.status_code != 200:
error_and_exit("%s %s" % (url, resp.status_code))
r_data = resp.json()
if r_data["status"] % 10000 < 100:
print(r_data["message"])
else:
error_and_exit(r_data["message"])
return r_data
def handle_key():
arg_man.add_argument("-a", "--app", dest="app", help=g_help("app"), metavar="app_name", default="")
arg_man.add_argument("-e", "--endpoint", dest="endpoint", help=g_help("endpoint"), metavar="Endpoint",
default=default_endpoint)
arg_man.add_argument("-f", "--filters", dest="filters", help=g_help("filters"), action="append", default=[])
arg_man.add_argument("-p", "--print", dest="print_key", help=g_help("print_key"), nargs="*", metavar="key")
arg_man.add_argument("--only-value", dest="only_value", help=g_help("only_value"), action="store_true",
default=False)
arg_man.add_argument("-r", "--replace", dest="replace_file", help=g_help("replace_file"), metavar="file")
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = arg_man.parse_args()
key_items = get_key(args.endpoint, args.app, args.filters)
replace_file(args.replace_file, key_items)
if args.print_key is not None:
for p_key in args.print_key:
if p_key in key_items:
if args.only_value is True:
print(key_items[p_key])
else:
print("%s\t%s" % (p_key, key_items[p_key]))
else:
error_and_exit(g_help("key_not_exist", p_key))
def add_output():
arg_man.add_argument("-o", "--output", dest="output", help=g_help("output"), metavar="output")
def check_file_exist(file_path):
if os.path.exists(file_path) is False:
error_and_exit(g_help("file_lost", file_path))
def main():
commands_man = args_man.add_subparsers(title="Commands",
description=None,
metavar="COMMAND",
dest="sub_cmd")
config_man = commands_man.add_parser("config",
help=g_help("action_config"))
config_man.add_argument("command", nargs="*", help=g_help("command"))
config_man.add_argument("-d",
dest="compose_dir",
help=g_help("compose_dir"))
config_man.add_argument("-e",
"--environment",
dest="environments",
help=g_help("env"),
action="append")
config_man.add_argument("-f",
"--file",
dest="file_path",
help=g_help("file"))
config_man.add_argument("-n",
"--name",
dest="name",
help=g_help("name"),
required=True)
config_man.add_argument("-i",
"--image",
dest="image",
help=g_help("image"),
required=True)
config_man.add_argument("-v",
"--volumes",
dest="volumes",
help=g_help("volumes"),
action="append")
config_man.add_argument("-p",
"--ports",
help=g_help("ports"),
action="append")
config_man.add_argument("--restart", help=g_help("restart"))
config_man.add_argument("-w",
"--working-dir",
dest="working_dir",
help=g_help("working_dir"))
# commands_man.add_parser("kill", help="")
# up_man = commands_man.add_parser("up", help="execute docker-compose up")
# up_man.add_argument("args", nargs="*")
if len(sys.argv) <= 1:
sys.argv.append("-h")
args = parse_args()
if args.sub_cmd == "config":
write_conf(args)
else:
file_path = get_file(None)
sys.argv.insert(1, "-f")
sys.argv.insert(2, file_path)
compose_main()
