def main(_args):
"""
initialize container
"""
envs = fn.getenv(file_env)
node = envs['NODE']
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
target = ""
if node != "all":
target = f"rds-{node}"
# サービス削除
cmd_down = "docker-compose down"
for line in fn.cmdlines(_cmd=cmd_down):
sys.stdout.write(line)
fn.rmdir(join(dir_scr, "vol", node))
# サービス作成
for line in fn.cmdlines(_cmd=f"docker-compose up -d {target}"):
sys.stdout.write(line)
def main(_args):
"""
initialize container
"""
env_dst = join(dir_scr, "..", '.env')
envs = fn.getenv(env_dst)
node = envs["NODE"]
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
container = f"node-mysql-{node}"
dir_dump = abspath(join(dir_base, "vol", node, "dump"))
fn.input_y(f"start to get {container} dump. (y/*):")
database = envs['MYSQL_DATABASE']
if _args.all:
database = "all"
dump_path = rp.getdump_docker(container, dir_dump,
f"{envs['OPTROOT']} -u root", database,
_args.compress)
fn.chmodr(dump_path, 0o777)
print(f"\n[info] generate dump file: [{dump_path}].")
def main(_args):
"""
initialize container
"""
env_dst = join(dir_scr, "..", '.env')
envs = fn.getenv(env_dst)
node = envs["NODE"]
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
container = f"node-mysql-{node}"
dk_cmd = f"docker exec -it {container}"
mysql_cmd = f"{dk_cmd} mysql {envs['OPTROOT']}"
master_host = f"{envs['MASTER_HOST']} : {envs['MASTER_PORT']}"
if node == "slave":
# デタッチ処理
if fn.input_yn(f"\ndetach from master[ {master_host} ]. ok? (y/*) :"):
print(f"\n---------- detach from [ {master_host} ] start")
cmds = [
f"{mysql_cmd} -e 'STOP SLAVE'",
f"{mysql_cmd} -e 'RESET SLAVE'",
]
for line in rp.cmdrun(_cmd=cmds, _encode="utf8"):
sys.stdout.write(line)
else:
print(f"[error] node type error.")
sys.exit()
def main(_args):
env_org = join(dir_scr, "_org", '.env')
env_file = join(dir_scr, '.env')
if _args.reset or not isfile(env_file):
print("[info] init .env file.")
shutil.copyfile(env_org, env_file)
params = fn.getenv(env_file)
fn.setparams(
params,
[
'TZ',
'DOMAIN',
'PORT_EXTERNAL',
# 'PORT_EXTERNAL2',
'MEM',
])
fn.setenv(params, env_file)
for k, v in params.items():
print(f"{k}={v}")
def main(_args):
print("----- redis env setting start.")
env_org = join(dir_scr, "_org", '.env')
env_file = join(dir_scr, '.env')
nconf_org = join(dir_scr, "_org", 'default.conf')
nconf_dst = join(dir_scr, "nginx", 'default.conf')
netrc_org = join(dir_scr, "_org", '.netrc')
netrc_dst = join(dir_scr, "django", '.netrc')
if _args.reset or not isfile(env_file):
print("[info] init .env file.")
shutil.copyfile(env_org, env_file)
params = fn.getenv(env_file)
fn.setparams(params, [
'TZ',
'APP_NAME',
'APP_DOMAIN',
'APP_PORT',
])
if fn.input_yn("get app source from git? (y/*) :"):
fn.setparams(params, [
'GIT_USER',
'GIT_TOKEN',
'GIT_REPO',
'GIT_BRANCH',
])
if fn.input_yn("use mysql databases? (y/*) :"):
fn.setparams(params, [
'MYSQL_MASTER_HOST',
'MYSQL_MASTER_PORT',
'MYSQL_SLAVE_HOST',
'MYSQL_SLAVE_PORT',
'MYSQL_ROOT_PASSWORD',
'MYSQL_USER_PASSWORD',
])
if fn.input_yn("use redis caches? (y/*) :"):
fn.setparams(params, [
'REDIS_MASTER_HOST',
'REDIS_MASTER_PORT',
'REDIS_MASTER_PASSWORD',
])
fn.setenv(params, env_file)
fn.update_file(params, nconf_org, "___", nconf_dst)
# netrcファイル作成
if params['GIT_REPO'] != "":
# URLをパースする
params['GIT_DOMAIN'] = urlparse(params['GIT_REPO']).netloc.replace(
"www.", "")
fn.update_file(params, netrc_org, "___", netrc_dst)
for k, v in params.items():
print(f"{k}={v}")
def main():
"""
initialize container
"""
# 環境変数に.env読み込み
param = fn.getenv(".env")
# 環境変数を参照
port_external = param['PORT_EXTERNAL']
# localhostのip取得
localhost = fn.local_ip()
dir_plugin = os.path.join(dir_scr, "plugins")
os.chdir(dir_scr)
print(f"[info] setting loaded.")
# コンテナ再構築
commands = []
reset_data = False
if fn.input_yn("reset container data. ok? (y/*) :"):
reset_data = True
commands.append("docker-compose down -v")
else:
commands.append("docker-compose down")
commands.append("docker-compose up -d")
for line in fn.cmdlines(_cmd=commands):
sys.stdout.write(line)
if reset_data:
# ボリューム削除時のみプラグイン再配置
print("[info] waiting 15s for starting sonarqube container...")
time.sleep(15)
print(f"----------sonarqube plugins copy")
plugins = glob.glob(f"{dir_plugin}/*.jar")
for p_path in plugins:
p_file = os.path.basename(p_path)
command = [
f"docker cp {p_path} sonarqube:/opt/sonarqube/extensions/plugins/{p_file}"
]
for line in fn.cmdlines(_cmd=command):
sys.stdout.write(line)
print("restart to load sonarqube plugins...")
for line in fn.cmdlines(_cmd="docker restart sonarqube"):
sys.stdout.write(line)
print("[info] waiting 15s for restarting sonarqube container...")
time.sleep(15)
print(f"access to http://{localhost}:{port_external}/")
def main(_args):
"""
initialize container
"""
# コンテナ削除
cmd_down = "docker-compose down -v"
for line in fn.cmdlines(_cmd=cmd_down):
sys.stdout.write(line)
fn.rmdir(join(dir_scr, "vol", "master", "data"))
fn.rmdir(join(dir_scr, "vol", "master", "log"))
fn.rmdir(join(dir_scr, "vol", "slave", "data"))
fn.rmdir(join(dir_scr, "vol", "slave", "log"))
fn.rmdir(join(dir_scr, "vol", "master", "dump"))
fn.rmdir(join(dir_scr, "vol", "slave", "dump"))
envs = fn.getenv(file_env)
node = envs['NODE']
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
print(f"[info] run {node} node.")
target = ""
if node != "all":
target = f"db-{node}"
# サービス作成
for line in fn.cmdlines(_cmd=f"docker-compose up -d {target}", _encode="utf8"):
sys.stdout.write(line)
# パーミッション調整(windows未検証)
if os.name == "nt":
nodes = ["node-mysql-master", "node-mysql-slave"]
if node != "all":
nodes = [f"node-mysql-{node}"]
for ref in nodes:
for line in fn.cmdlines(_cmd=f"docker exec -it {ref} chmod -R 664 /etc/mysql/conf.d"):
sys.stdout.write(line)
for line in fn.cmdlines(_cmd=f"docker exec -it {ref} chmod -R 664 /tmp/common/opt"):
sys.stdout.write(line)
fn.rmdir(join(dir_scr, "vol", node, "data"), True)
# サービス作成
for line in fn.cmdlines(_cmd=f"docker-compose restart {target}"):
sys.stdout.write(line)
def main():
"""
initialize container
"""
env_org = join(dir_scr, '_org', '.env')
env_dst = join(dir_scr, '.env')
if not isfile(env_dst):
shutil.copyfile(env_org, env_dst)
if not fn.input_yn("initialize container. ok? (y/*) :"):
print("[info] initialize container canceled.")
# .env読み込み
param = fn.getenv(env_dst)
# 環境変数を参照
domain = param['DOMAIN']
# コンテナ削除
for line in fn.cmdlines(_cmd="docker-compose down"):
sys.stdout.write(line)
for line in fn.cmdlines(_cmd="docker-compose up -d"):
sys.stdout.write(line)
localhost = fn.local_ip()
print(f"""\
----------gitlab started.
add hosts.
-----
{localhost} gitlab.{domain} mattermost.{domain} registry.{domain}
-----
""")
print(f"""\
----------wait 5min to start gitlab
check status [docker-compose logs gitlab]
access to http://gitlab.{domain}/
and set root account password
""")
print("----------container initialize end.")
def main(_args):
"""
initialize container
"""
env_dst = join(dir_scr, "..", '.env')
envs = fn.getenv(env_dst)
node = envs["NODE"]
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
container = f"node-mysql-{node}"
dk_cmd = f"docker exec -it {container}"
mysql_cmd = f"{dk_cmd} mysql {envs['OPTROOT']}"
master_host = f"{envs['MASTER_HOST']} : {envs['MASTER_PORT']}"
# アタッチ処理
if node == "slave":
if fn.input_yn(f"\nattach to master[ {master_host} ]. ok? (y/*) :"):
print(f"\n---------- attach to [ {master_host} ] start")
cmd = f"{mysql_cmd} -e \"\
CHANGE MASTER TO \
{envs['REP_FILE']}, \
{envs['REP_POS']}, \
MASTER_HOST='{envs['MASTER_HOST']}', \
MASTER_PORT={envs['MASTER_PORT']}, \
MASTER_USER='******', \
MASTER_PASSWORD='******'MYSQL_REP_PASSWORD']}';\
\""
for line in rp.cmdrun(_cmd=[cmd], _encode="utf8"):
sys.stdout.write(line)
cmds = [
f"{dk_cmd} bash -c \"mysql {envs['OPTROOT']} -e 'START SLAVE;'\"",
]
for line in rp.cmdrun(_cmd=cmds, _encode="utf8"):
sys.stdout.write(line)
else:
print(f"[error] node type error.")
sys.exit()
def main(_args):
print("----- redis env setting start.")
env_org = join(dir_scr, "_org", '.env')
env_file = join(dir_scr, '.env')
nconf_org = join(dir_scr, "_org", 'default.conf')
nconf_dst = join(dir_scr, "nginx", 'default.conf')
netrc_org = join(dir_scr, "_org", '.netrc')
netrc_dst = join(dir_scr, "php", '.netrc')
if _args.reset or not isfile(env_file):
print("[info] init .env file.")
shutil.copyfile(env_org, env_file)
params = fn.getenv(env_file)
req_keys = [
'TZ',
'APP_NAME',
'APP_DOMAIN',
'APP_PORT',
'PORT_INTERNAL',
]
_input = input("get app source from git. ok? (y/*) :").lower()
if _input in ["y", "yes"]:
req_keys.append('GIT_USER')
req_keys.append('GIT_TOKEN')
req_keys.append('GIT_REPO')
req_keys.append('GIT_BRANCH')
else:
req_keys.append('LARAVEL_VER')
fn.setparams(params, req_keys)
fn.setenv(params, env_file)
fn.update_file(params, nconf_org, "___", nconf_dst)
if params['GIT_REPO'] != "":
# URLをパースする
params['GIT_DOMAIN'] = urlparse(params['GIT_REPO']).netloc.replace(
"www.", "")
fn.update_file(params, netrc_org, "___", netrc_dst)
for k, v in params.items():
print(f"{k}={v}")
def main(_args):
print("----- redis env setting start.")
env_org = join(dir_scr, "_org", '.env')
env_file = join(dir_scr, '.env')
if _args.reset or not isfile(env_file):
print("[info] init .env file.")
shutil.copyfile(env_org, env_file)
params = fn.getenv(env_file)
fn.setparams(params, [
'PORT_EXTERNAL',
'MEM',
'MEM_DB',
])
fn.setenv(params, env_file)
def main(_args):
print("----- redis env setting start.")
env_file = join(dir_scr, '.env')
env_org = join(dir_scr, "_org", '.env')
if not isfile(env_file):
shutil.copyfile(env_org, env_file)
params = fn.getenv(env_file)
if _args.node == 'master':
if params['MASTER_PASS'] == "":
params['MASTER_PASS'] = fn.randstr(30)
req_keys = [
'TZ',
'MASTER_PORT',
'MASTER_PASS',
'MEM',
]
fn.setparams(params, req_keys)
if params['SLAVE_PASS'] == "":
params['SLAVE_PASS'] = params['MASTER_PASS']
if params['SLAVE_PORT'] == params['MASTER_PORT']:
params['SLAVE_PORT'] = str(int(params['MASTER_PORT']) + 1)
params['MASTER_HOST'] = fn.local_ip()
elif _args.node == 'slave':
if params['SLAVE_PASS'] == "":
params['SLAVE_PASS'] = fn.randstr(30)
req_keys = [
'TZ',
'SLAVE_PORT',
'SLAVE_PASS',
'MASTER_HOST',
'MASTER_PORT',
'MASTER_PASS',
'MEM',
]
fn.setparams(params, req_keys)
params['SLAVE_HOST'] = fn.local_ip()
params['NODE'] = _args.node
fn.setenv(params, env_file)
for k, v in params.items():
print(f"{k}={v}")
def main(_args):
"""
initialize container
"""
params = fn.getenv(file_env)
# コンテナ削除
if not _args.debug:
for line in fn.cmdlines(_cmd="docker-compose down -v"):
sys.stdout.write(line)
# ログリセット
fn.rmdir(join(dir_scr, "log"))
# ソースリセット
fn.rmdir(join(dir_scr, "src"))
dir_project = join(dir_scr, "src")
if not isdir(dir_project):
if params['GIT_REPO'] == "":
# templateをコピー
dir_template = join(dir_scr, "django", "project")
params['APP_NAME_PASCAL'] = str(params['APP_NAME']).capitalize()
fn.copydir(dir_template, dir_project, params)
fn.rmdir(join(dir_project, "app"), True)
fn.copydir(join(dir_template, "app"),
join(dir_project, params['APP_NAME']), params)
fn.rmdir(join(dir_project, "templates", "app"), True)
fn.copydir(join(dir_template, "templates", "app"),
join(dir_project, "templates", params['APP_NAME']),
params)
else:
# gitからリポジトリクローン
gituser = params['GIT_USER']
if "gitlab" in params['GIT_REPO']:
print("[info] clone from gitlab.")
gituser = "******"
clone_url = params['GIT_REPO'].replace(
"://", f"://{gituser}:{params['GIT_TOKEN']}@")
cmd = f"git clone"
if params['GIT_BRANCH'] != "":
cmd += f" -b {params['GIT_BRANCH']}"
cmd += f" {clone_url} {dir_project}"
for line in fn.cmdlines(_cmd=cmd):
sys.stdout.write(line)
# 内部でgitの更新できるようnetrc作成
netrc_path = join(dir_scr, "django", ".netrc")
if isfile(netrc_path):
cmd = f"docker cp {netrc_path} node-app-django:/root"
for line in fn.cmdlines(_cmd=cmd):
sys.stdout.write(line)
# コンテナ作成
if not _args.debug:
if fn.input_yn("start https-portal container? (y/*) :"):
for line in fn.cmdlines(_cmd=f"docker-compose up -d"):
sys.stdout.write(line)
else:
for line in fn.cmdlines(_cmd=f"docker-compose up -d web"):
sys.stdout.write(line)
# django前処理
if params['GIT_REPO'] == "":
docker_cmd = "docker exec -it node-app-django"
for line in fn.cmdlines(
_cmd=f"{docker_cmd} python3 ./manage.py makemigrations"):
sys.stdout.write(line)
for line in fn.cmdlines(
_cmd=f"{docker_cmd} python3 ./manage.py migrate"):
sys.stdout.write(line)
for line in fn.cmdlines(
_cmd=f"{docker_cmd} python3 ./manage.py createsuperuser"):
sys.stdout.write(line)
def main():
"""
initialize container
"""
params = fn.getenv(file_env)
# コンテナ削除
for line in fn.cmdlines(_cmd="docker-compose down"):
sys.stdout.write(line)
# ログリセット
fn.rmdir(join(dir_scr, "log"))
# ソースリセット
fn.rmdir(join(dir_scr, "src"))
# コンテナ作成
for line in fn.cmdlines(_cmd=f"docker-compose up -d"):
sys.stdout.write(line)
docker_exec = "docker exec -it node-app-laravel"
dir_app = join(dir_scr, "src", params['APP_NAME'])
if not isdir(dir_app):
if params['GIT_REPO'] == "":
cmd = f"{docker_exec} composer create-project --prefer-dist laravel/laravel={params['LARAVEL_VER']} {params['APP_NAME']}"
for line in fn.cmdlines(_cmd=cmd):
sys.stdout.write(line)
else:
# gitからリポジトリクローン
gituser = params['GIT_USER']
netrc_path = join(dir_scr, "php", ".netrc")
if isfile(netrc_path):
cmd = f"docker cp {netrc_path} app-php:/root"
for line in fn.cmdlines(_cmd=cmd):
sys.stdout.write(line)
if "gitlab" in params['GIT_REPO']:
print("[info] clone from gitlab.")
gituser = "******"
clone_url = params['GIT_REPO'].replace(
"://", f"://{gituser}:{params['GIT_TOKEN']}@")
cmd = f"{docker_exec} git clone {clone_url} {params['APP_NAME']}"
if params['GIT_BRANCH'] != "":
cmd = f"{docker_exec} git clone -b {params['GIT_BRANCH']} {clone_url} {params['APP_NAME']}"
for line in fn.cmdlines(_cmd=cmd):
sys.stdout.write(line)
# パーミッション
for line in fn.cmdlines(
_cmd=
f"{docker_exec} chmod -R 777 {params['APP_NAME']}/storage/framework"
):
sys.stdout.write(line)
# composer load
print(f"""[info] execute composer dump-autoload.
----------
{docker_exec} bash
cd /var/www/html/{params['APP_NAME']}
composer dump-autoload
----------""")
"""
import os
from helper import getenv
# Build paths inside the project like this: os.path.join(BASE_DIR, ...)
BASE_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
# Quick-start development settings - unsuitable for production
# See https://docs.djangoproject.com/en/1.10/howto/deployment/checklist/
# SECURITY WARNING: keep the secret key used in production secret!
SECRET_KEY = 'lys5d7z-zkx7e%z64f=97^ya=&bl%v)hbg7!+fs2i3v(jk%ct5'
# SECURITY WARNING: don't run with debug turned on in production!
DEBUG = getenv('APP_DEBUG')
ALLOWED_HOSTS = []
# Application definition
INSTALLED_APPS = [
# 'django.contrib.admin',
# 'django.contrib.auth',
'django.contrib.contenttypes',
'django.contrib.sessions',
'django.contrib.messages',
'django.contrib.staticfiles',
'stripe_service',
]
def main(_args):
"""
initialize container
"""
env_dst = join(dir_scr, "..", '.env')
envs = fn.getenv(env_dst)
node = envs["NODE"]
if not _args.node is None:
node = _args.node
if node == "":
print(f"[error] node type not set.")
sys.exit()
container = f"node-mysql-{node}"
dk_cmd = f"docker exec -it {container}"
mysql_cmd = f"{dk_cmd} mysql {envs['OPTROOT']}"
master_host = f"{envs['MASTER_HOST']} : {envs['MASTER_PORT']}"
if node == "slave":
# デタッチ処理
if fn.input_yn(f"\ndetach from master[ {master_host} ]. ok? (y/*) :"):
print(f"\n---------- detach from [ {master_host} ] start")
cmds = [
f"{mysql_cmd} -e 'STOP SLAVE'",
f"{mysql_cmd} -e 'RESET SLAVE'",
]
for line in rp.cmdrun(_cmd=cmds, _encode="utf8"):
sys.stdout.write(line)
# リストア対象の指定
dir_dump = abspath(join(dir_base, "vol", node, "dump"))
print("\n----- dump directories")
for ref in os.listdir(dir_dump):
if isdir(join(dir_dump, ref)):
print(ref)
_input = input("\nrequire restore target dump directry. (empty to skip):")
dir_dump_ref = join(dir_dump, _input)
if _input != "":
if not isdir(dir_dump_ref):
print("[error] restore target none.")
sys.exit()
path_dump = f"/tmp/dump/{_input}/bin.dump"
path_dump_ref = join(dir_dump_ref, "bin.dump")
# リストア処理
print(f"\n---------- restore to {container} start")
cmds = [
f"{mysql_cmd} -e 'SET PERSIST innodb_flush_log_at_trx_commit = 0'",
f"{mysql_cmd} -e 'SET PERSIST sync_binlog = 0'",
]
for line in rp.cmdrun(_cmd=cmds):
sys.stdout.write(line)
cmds = [f"{dk_cmd} bash -c 'mysql {envs['OPTROOT']} < {path_dump}'"]
for line in rp.cmdrun(_cmd=cmds, _encode="utf8"):
sys.stdout.write(line)
cmds = [
f"{mysql_cmd} -e 'SET PERSIST innodb_flush_log_at_trx_commit = 1'",
f"{mysql_cmd} -e 'SET PERSIST sync_binlog = 1'",
]
for line in rp.cmdrun(_cmd=cmds):
sys.stdout.write(line)
path_status = join(dir_dump_ref, "status.txt")
status_cmd = ""
with open(path_status) as f:
status_cmd = f.read()
spl_status = status_cmd.split(" ")
for st in spl_status:
if "MASTER_LOG_FILE" in st:
envs['REP_FILE'] = st.replace(",", "")
if "MASTER_LOG_POS" in st:
envs['REP_POS'] = st.replace(",", "")
fn.setenv(envs, env_dst)
print(f"\n---------- restore to {container} end")
# アタッチ処理
if node == "slave":
if fn.input_yn(f"\nattach to master[ {master_host} ]. ok? (y/*) :"):
print(f"\n---------- attach to [ {master_host} ] start")
cmd = f"{mysql_cmd} -e \"\
CHANGE MASTER TO \
{envs['REP_FILE']}, \
{envs['REP_POS']}, \
MASTER_HOST='{envs['MASTER_HOST']}', \
MASTER_PORT={envs['MASTER_PORT']}, \
MASTER_USER='******', \
MASTER_PASSWORD='******'MYSQL_REP_PASSWORD']}';\
\""
for line in rp.cmdrun(_cmd=[cmd], _encode="utf8"):
sys.stdout.write(line)
cmds = [
f"{dk_cmd} bash -c \"mysql {envs['OPTROOT']} -e 'START SLAVE;'\"",
]
for line in rp.cmdrun(_cmd=cmds, _encode="utf8"):
sys.stdout.write(line)
def main(_args):
print("----- mysql setting start.")
env_dst = join(dir_scr, '.env')
env_org = join(dir_scr, "_org", '.env')
if not isfile(env_dst):
shutil.copyfile(env_org, env_dst)
params = fn.getenv(env_dst)
if params['MYSQL_ROOT_PASSWORD'] == "":
params['MYSQL_ROOT_PASSWORD'] = fn.randstr(30)
if params['MYSQL_REP_PASSWORD'] == "":
params['MYSQL_REP_PASSWORD'] = fn.randstr(30)
if params['MYSQL_USER_PASSWORD'] == "":
params['MYSQL_USER_PASSWORD'] = fn.randstr(30)
req_keys = [
'TZ',
'MYSQL_ROOT_PASSWORD',
'MYSQL_REP_PASSWORD',
'MYSQL_USER_PASSWORD',
'MEM',
]
if _args.node == 'master':
req_keys.append('MASTER_PORT')
req_keys.append('MASTER_SERVER_ID')
params['MASTER_HOST'] = fn.local_ip()
elif _args.node == 'slave':
req_keys.append('SLAVE_PORT')
req_keys.append('SLAVE_SERVER_ID')
req_keys.append('MASTER_HOST')
req_keys.append('MASTER_PORT')
fn.setparams(params, req_keys)
params['NODE'] = _args.node
fn.setenv(params, env_dst)
# confのコピー
for ref in ["master", "slave"]:
conf_org = join(dir_scr, '_org', 'conf', ref, 'rep.cnf')
dir_conf = join(dir_scr, 'mnt', 'conf', ref)
if not isdir(dir_conf):
os.makedirs(dir_conf)
fn.update_file(params, conf_org, '___', join(dir_conf, 'rep.cnf'))
# fn.chmodr(dir_conf, 0o644)
# fn.chownr(dir_conf, "root", "root")
# mysqlのログイン用ファイルコピー
users = ["root", "rep", "user"]
dir_opt_org = join(dir_scr, '_org', 'opt')
dir_opt = join(dir_scr, 'mnt', 'common', 'opt')
if not isdir(dir_opt):
os.makedirs(dir_opt)
for user in users:
opt_org = join(dir_opt_org, f".opt{user}")
opt_dst = join(dir_opt, f".opt{user}")
fn.update_file(params, opt_org, '___', opt_dst)
# fn.chmodr(dir_opt, 0o644)
# fn.chownr(dir_opt, "root", "root")
for k,v in params.items():
print(f"{k}={v}")
