789 lines
27 KiB
Python
Executable File
789 lines
27 KiB
Python
Executable File
#!/usr/bin/env python3
|
|
import argparse
|
|
from collections import OrderedDict
|
|
import os
|
|
import re
|
|
import shutil
|
|
import subprocess
|
|
import yaml
|
|
import stat
|
|
import zlib
|
|
from datetime import datetime
|
|
import socket
|
|
try:
|
|
import requests
|
|
except ImportError:
|
|
print("Installing required dependencies...")
|
|
subprocess.check_call(
|
|
[
|
|
"pip3",
|
|
"install",
|
|
"requests",
|
|
]
|
|
)
|
|
import requests
|
|
try:
|
|
from filelock import Timeout, FileLock
|
|
except ImportError:
|
|
print("Installing required dependencies...")
|
|
subprocess.check_call(
|
|
[
|
|
"pip3",
|
|
"install",
|
|
"filelock",
|
|
]
|
|
)
|
|
from filelock import Timeout, FileLock
|
|
|
|
guru_dir = os.path.expanduser("~/.guru-external")
|
|
current_dir = os.getcwd()
|
|
|
|
gurusdk_giturl = "git@git.chengdu.pundit.company:castbox/gurusdk.git"
|
|
gurumodules_giturl = "git@git.chengdu.pundit.company:castbox/guru_modules.git"
|
|
gurusdk_use_submodule = False
|
|
|
|
|
|
def get_guru_dir():
|
|
return guru_dir
|
|
|
|
|
|
def get_guru_flutter_dir():
|
|
return f"{get_guru_dir()}/flutter"
|
|
|
|
|
|
def get_gurusdk_root():
|
|
return f"{get_guru_flutter_dir()}/gurusdk"
|
|
|
|
|
|
def get_gurusdk_integrated_dir(app):
|
|
return f"{get_gurusdk_root()}/integrated/{app}"
|
|
|
|
|
|
def get_gurusdk_runtime_dir(app):
|
|
return f"{get_gurusdk_integrated_dir(app)}/gurusdk"
|
|
|
|
|
|
def get_gurusdk_compiler_dir(app):
|
|
return f"{get_gurusdk_integrated_dir(app)}/gurusdk_compiler"
|
|
|
|
|
|
def calculate_pubspec_crc32(pubpaths, initial_crc=0):
|
|
crc = initial_crc # 初始 CRC 值
|
|
for pubspec_path in pubpaths:
|
|
# 更新 CRC 值，注意确保数据块是字节串
|
|
with open(pubspec_path, "r") as file:
|
|
data = file.read()
|
|
crc = zlib.crc32(data.encode("utf-8"), crc)
|
|
return crc
|
|
|
|
|
|
def change_dart_files_readonly(directory):
|
|
for root, dirs, files in os.walk(directory):
|
|
for file in files:
|
|
if file.endswith(".dart"):
|
|
full_path = os.path.join(root, file)
|
|
current_permissions = os.stat(full_path).st_mode
|
|
readonly_permissions = current_permissions & ~stat.S_IWRITE
|
|
os.chmod(full_path, readonly_permissions)
|
|
|
|
|
|
def search_pkg_dirs(target_root):
|
|
results = []
|
|
for dirpath, dirnames, filenames in os.walk(target_root):
|
|
# Check if the file is a pubspec.yaml file
|
|
for filename in filenames:
|
|
if filename == "pubspec.yaml":
|
|
dir = dirpath.removeprefix(f"{target_root}/")
|
|
results.append(dir)
|
|
return results
|
|
|
|
|
|
def gurusdk_crc32(version, target_dir):
|
|
pkg_dirs = search_pkg_dirs(target_dir)
|
|
pubpaths = []
|
|
initial_crc = zlib.crc32(version.encode("utf-8"), 2627)
|
|
pkg_dirs.sort()
|
|
for dir in pkg_dirs:
|
|
package_name = os.path.basename(dir)
|
|
if package_name not in invalid_pkgs and package_name not in dev_pkgs:
|
|
pubpaths.append(f"{target_dir}/{dir}/pubspec.yaml")
|
|
return calculate_pubspec_crc32(pubpaths, initial_crc=initial_crc)
|
|
|
|
|
|
invalid_pkgs = {"example", "flutter_2048", "showcase"}
|
|
|
|
dev_pkgs = {"guru_splash_flutter"}
|
|
|
|
|
|
def gurusdk_snapshot(version, target_dir):
|
|
os.chdir(target_dir)
|
|
crc = gurusdk_crc32(version, target_dir)
|
|
print(f"crc32: {crc}")
|
|
cmdrun(f"echo '[CRC]{crc}' > .gurusdk")
|
|
if gurusdk_use_submodule:
|
|
cmdrun(f"git submodule >> .gurusdk")
|
|
|
|
|
|
def gurusdk_dir():
|
|
if not os.path.exists("gurusdk.yaml"):
|
|
gsdir = cmdrun("which gurusdk", loggable=False)[0]
|
|
while len(gsdir) > 0:
|
|
gsdir = os.path.dirname(gsdir)
|
|
if is_gurusdk_dir(gsdir):
|
|
print(gsdir)
|
|
exit(0)
|
|
exit(-1)
|
|
|
|
with open("gurusdk.yaml", "r") as file:
|
|
config = yaml.safe_load(file)
|
|
with open("pubspec.yaml", "r") as file:
|
|
pubspec_config = yaml.safe_load(file)
|
|
if pubspec_config.get("gurulib", False):
|
|
print("\033[31m" + "`update` action Not Support gurulib!" + "\033[0m")
|
|
exit(-1)
|
|
app = pubspec_config["name"]
|
|
dir = get_gurusdk_integrated_dir(app)
|
|
print(dir)
|
|
exit(0)
|
|
|
|
|
|
def gurusdk_update():
|
|
os.chdir(current_dir)
|
|
with open("gurusdk.yaml", "r") as file:
|
|
config = yaml.safe_load(file)
|
|
with open("pubspec.yaml", "r") as file:
|
|
pubspec_config = yaml.safe_load(file)
|
|
if pubspec_config.get("gurulib", False):
|
|
print("Not Support gurulib project")
|
|
print("\033[31m" + "`update` action Not Support gurulib!" + "\033[0m")
|
|
exit(0)
|
|
app = pubspec_config["name"]
|
|
gurusdk_runtime_dir = get_gurusdk_runtime_dir(app)
|
|
runtime_lock = {}
|
|
if not os.path.exists(f"{gurusdk_runtime_dir}/gurusdk.lock"):
|
|
print(
|
|
"\033[31m"
|
|
+ "gurusdk.lock not found! please use `gurusdk get` command first"
|
|
+ "\033[0m"
|
|
)
|
|
exit(0)
|
|
|
|
with open(f"{gurusdk_runtime_dir}/gurusdk.lock", "r") as file:
|
|
runtime_lock.update(yaml.safe_load(file))
|
|
locked_version = runtime_lock["guru_sdk"]
|
|
version = config["guru_sdk"]
|
|
if locked_version != version:
|
|
print(
|
|
"\033[31m"
|
|
+ f"Locked version({locked_version}) != config version({version}), please use `gurusdk get` command first"
|
|
+ "\033[0m"
|
|
)
|
|
exit(0)
|
|
version_dir = f"{get_gurusdk_root()}/{version}"
|
|
if os.path.exists(f"{version_dir}/sdk_commit"):
|
|
with open(f"{version_dir}/sdk_commit", "r") as file:
|
|
sdk_commit = file.readline().strip()
|
|
resolved_ref = cmdrun(
|
|
f"git ls-remote {gurusdk_giturl} {version} | awk '{{print $1}}'"
|
|
)[0]
|
|
print("sdk_commit: ", sdk_commit, "resolved_ref: ", resolved_ref)
|
|
if sdk_commit != resolved_ref:
|
|
gurusdk_download(version, force=True)
|
|
else:
|
|
gurusdk_download(version, force=True)
|
|
|
|
|
|
def gurusdk_download(version, force=False):
|
|
gurusdk_root = get_gurusdk_root()
|
|
gurusdk_version_dir = f"{gurusdk_root}/{version}"
|
|
if os.path.exists(gurusdk_version_dir):
|
|
crc32 = gurusdk_crc32(version, gurusdk_version_dir)
|
|
with open(f"{gurusdk_version_dir}/.gurusdk", "r") as file:
|
|
filedata = file.readline().strip()
|
|
crcStr = f"[CRC]{crc32}"
|
|
if filedata != crcStr:
|
|
print(
|
|
f"{filedata} != {crcStr}! remove {gurusdk_version_dir}, re-download.."
|
|
)
|
|
shutil.rmtree(gurusdk_version_dir)
|
|
|
|
version_dir_exists = os.path.exists(gurusdk_version_dir)
|
|
if force or not version_dir_exists:
|
|
if version_dir_exists:
|
|
shutil.rmtree(gurusdk_version_dir)
|
|
os.chdir(gurusdk_root)
|
|
os.system(
|
|
f"git clone -b {version} --single-branch --depth 1 {gurusdk_giturl} {version}"
|
|
)
|
|
os.chdir(gurusdk_version_dir)
|
|
if gurusdk_use_submodule:
|
|
os.system("git submodule init")
|
|
os.system("git submodule update")
|
|
os.remove(".gitmodules")
|
|
cmdrun("git rev-parse HEAD > sdk_commit")
|
|
shutil.rmtree(f".git")
|
|
change_dart_files_readonly(gurusdk_version_dir)
|
|
return gurusdk_version_dir
|
|
|
|
|
|
def guru_modules_sync():
|
|
guru_flutter_dir = get_guru_flutter_dir()
|
|
guru_modules_dir = f"{guru_flutter_dir}/guru_modules"
|
|
if os.path.exists(guru_modules_dir) != True:
|
|
os.makedirs(guru_flutter_dir, exist_ok=True)
|
|
os.chdir(guru_flutter_dir)
|
|
os.system(
|
|
f"git clone {gurumodules_giturl} {guru_modules_dir}"
|
|
)
|
|
else:
|
|
os.chdir(guru_modules_dir)
|
|
cmdrun("git reset --hard HEAD")
|
|
os.system("git pull --rebase")
|
|
os.chdir(current_dir)
|
|
return guru_modules_dir
|
|
|
|
|
|
def get_git_relative_path():
|
|
try:
|
|
git_root = subprocess.check_output(
|
|
["git", "rev-parse", "--show-toplevel"], encoding="utf-8"
|
|
).strip()
|
|
return os.path.relpath(current_dir, git_root)
|
|
except subprocess.CalledProcessError:
|
|
print("current directory is not a git repository")
|
|
|
|
|
|
def gurusdk_publish():
|
|
if os.path.exists("gurusdk.yaml") != True:
|
|
print("\033[31m" + "gurusdk.yaml not found" + "\033[0m")
|
|
exit(1)
|
|
with open("gurusdk.yaml", "r") as file:
|
|
gurusdk = yaml.safe_load(file)
|
|
|
|
if os.path.exists("pubspec.yaml") != True:
|
|
print("\033[31m" + "pubspec.yaml not found" + "\033[0m")
|
|
exit(1)
|
|
with open("pubspec.yaml", "r") as file:
|
|
pubspec = yaml.safe_load(file)
|
|
|
|
libname = pubspec.get("name", None)
|
|
if not libname:
|
|
print("\033[31m" + "`name` is required in pubspec.yaml" + "\033[0m")
|
|
exit(1)
|
|
|
|
if not pubspec.get("gurulib", False):
|
|
print(
|
|
"\033[31m"
|
|
+ "Not a gurulib project, please set gurulib: true in pubspec.yaml"
|
|
+ "\033[0m"
|
|
)
|
|
exit(1)
|
|
|
|
if not pubspec.get("dependencies", {}).get(f"{libname}_gurusdk", None):
|
|
print(
|
|
"\033[31m"
|
|
+ f"Please use `gurusdk get` command to add {libname}_gurusdk"
|
|
+ "\033[0m"
|
|
)
|
|
if not pubspec.get("dev_dependencies", {}).get(f"{libname}_gurusdk_compiler", None):
|
|
print(
|
|
"\033[31m"
|
|
+ f"Please use `gurusdk get` command to add {libname}_gurusdk_compiler"
|
|
+ "\033[0m"
|
|
)
|
|
|
|
guru_modules_dir = guru_modules_sync()
|
|
with open(f"{guru_modules_dir}/guru_modules.yaml", "r") as file:
|
|
gurumodules = yaml.safe_load(file)
|
|
if libname in gurumodules:
|
|
print("\033[31m" + f"Module({libname}) already published" + "\033[0m")
|
|
exit(1)
|
|
|
|
modules = gurusdk.get("modules", {})
|
|
for module in modules.keys():
|
|
if module not in gurumodules:
|
|
print(
|
|
"\033[31m"
|
|
+ f"{libname} depends on {module}, but {module} not published! please publish {module} first"
|
|
+ "\033[0m"
|
|
)
|
|
exit(1)
|
|
|
|
giturl = cmdrun("git remote get-url origin")[0]
|
|
gitpath = get_git_relative_path()
|
|
print("giturl: ", giturl, "gitpath: ", gitpath)
|
|
gurumodules[libname] = {"git": f"{giturl}"}
|
|
if gitpath != ".":
|
|
gurumodules[libname]["path"] = gitpath
|
|
|
|
resolved_ref = cmdrun(
|
|
f"git ls-remote origin module/{libname} | awk '{{print $1}}'"
|
|
)[0]
|
|
if resolved_ref != "":
|
|
print(
|
|
"\033[31m"
|
|
+ f"Already published {libname} module! Please contact Haoyi as soon as possible to help with the review."
|
|
+ "\033[0m"
|
|
)
|
|
exit(1)
|
|
|
|
os.chdir(guru_modules_dir)
|
|
cmdrun(f"git checkout main")
|
|
cmdrun(f"git branch -D module/{libname}", loggable=False),
|
|
|
|
checkout_result = checkout_result = batch_cmdrun(
|
|
[f"git checkout -b module/{libname}"]
|
|
)
|
|
|
|
if not checkout_result:
|
|
print("\033[31m" + "checkout failed" + "\033[0m")
|
|
exit(1)
|
|
|
|
with open(f"{guru_modules_dir}/guru_modules.yaml", "w") as file:
|
|
yaml.dump(gurumodules, file)
|
|
|
|
result = batch_cmdrun(
|
|
[
|
|
"git add guru_modules.yaml",
|
|
f"git commit -s -m 'publish `{libname}` module!'",
|
|
f"git push --set-upstream origin module/{libname}",
|
|
"git checkout main",
|
|
f"git branch -D module/{libname}",
|
|
]
|
|
)
|
|
if not result:
|
|
print("\033[31m" + "publish failed" + "\033[0m")
|
|
exit(1)
|
|
user_name = cmdrun("git config user.name")[0]
|
|
user_email = cmdrun("git config user.email")[0]
|
|
send_module_publish_notice(libname, user_name, user_email, giturl, gitpath)
|
|
|
|
os.chdir(current_dir)
|
|
print(f"Publish {libname} Module Success!")
|
|
|
|
def send_module_publish_notice(module, user, email, giturl, gitpath):
|
|
now = datetime.now()
|
|
formatted_datetime = now.strftime("%Y-%m-%d %H:%M:%S")
|
|
hostname = socket.gethostname()
|
|
url = f"https://github.com/castbox/guru_modules/tree/module/{module}"
|
|
content_text = f"""<font color=\"info\">【模块提审】</font> <font color=\"warning\">{user}</font>提交<font color=\"warning\">「{module}」</font>模块审核！[点击跳转]({url})
|
|
|
|
### 审核信息
|
|
>`仓库`: <font color=\"info\">{giturl}</font>
|
|
>`路径`: <font color=\"info\">{gitpath}</font>
|
|
|
|
### 提交信息
|
|
>`邮箱`: <font color=\"comment\">{email}</font>
|
|
>`日期`: <font color=\"comment\">{formatted_datetime}</font>
|
|
>`主机`: <font color=\"comment\">{hostname}</font>"""
|
|
|
|
content = {"content": content_text}
|
|
|
|
body = {"msgtype": "markdown", "markdown": content}
|
|
|
|
headers = {"Content-Type": "application/json"}
|
|
|
|
requests.post(
|
|
"https://qyapi.weixin.qq.com/cgi-bin/webhook/send?key=031c61ce-b504-45ac-b955-67c7e3ed840b",
|
|
json=body,
|
|
headers=headers,
|
|
)
|
|
|
|
|
|
def extract_git_name(url):
|
|
match = re.search(r"/([^/]+)\.git$", url) or re.search(r":([^/]+)\.git$", url)
|
|
if match:
|
|
return match.group(1)
|
|
raise ValueError("Invalid git url: {url}")
|
|
|
|
|
|
def import_modules(app, modules, runtime_pubspec_file, locked_modules={}, refs={}):
|
|
guru_flutter_dir = get_guru_flutter_dir()
|
|
gurusdk_root = get_gurusdk_root()
|
|
gurusdk_runtime_dir = get_gurusdk_runtime_dir(app)
|
|
|
|
os.makedirs(f"{gurusdk_root}/modules", exist_ok=True)
|
|
os.chdir(f"{gurusdk_root}/modules")
|
|
runtime_pkg_dir = f"{gurusdk_runtime_dir}/packages"
|
|
os.makedirs(f"{runtime_pkg_dir}", exist_ok=True)
|
|
|
|
if not os.path.exists(f"{guru_flutter_dir}/guru_modules/guru_modules.yaml"):
|
|
cmdrun(
|
|
f"git clone {gurumodules_giturl} {guru_flutter_dir}/guru_modules"
|
|
)
|
|
else:
|
|
guru_modules_sync()
|
|
|
|
with open(f"{guru_flutter_dir}/guru_modules/guru_modules.yaml", "r") as file:
|
|
gurumodules = yaml.safe_load(file)
|
|
runtime_modules = {}
|
|
for module, branch in modules.items():
|
|
if module in gurumodules:
|
|
if os.path.isdir(branch) and os.path.exists(f"{branch}/pubspec.yaml"):
|
|
module_path = branch
|
|
else:
|
|
module_info = gurumodules[module]
|
|
runtime_module_info = locked_modules.get(module, {})
|
|
giturl = module_info["git"]
|
|
repo_name = extract_git_name(giturl)
|
|
resolved_ref = ""
|
|
|
|
if (
|
|
runtime_module_info.get("git", "-") == giturl
|
|
and runtime_module_info.get("ref", "") == branch
|
|
):
|
|
resolved_ref = runtime_module_info["resolved-ref"]
|
|
|
|
if resolved_ref == "":
|
|
resolved_ref = cmdrun(
|
|
f"git ls-remote {giturl} {branch} | awk '{{print $1}}'"
|
|
)[0]
|
|
|
|
module_path = f"{gurusdk_root}/modules/{repo_name}-{resolved_ref}"
|
|
if not os.path.exists(module_path):
|
|
cmdrun(
|
|
f"git clone -b {branch} --single-branch --depth 1 {giturl} {module_path}"
|
|
)
|
|
os.chdir(module_path)
|
|
curren_resolved_ref = cmdrun(f"git rev-parse HEAD")[0]
|
|
shutil.rmtree(f"{module_path}/.git")
|
|
print(
|
|
"resuloved_ref: ",
|
|
resolved_ref,
|
|
"curren_resolved_ref:",
|
|
curren_resolved_ref,
|
|
)
|
|
if curren_resolved_ref != resolved_ref:
|
|
os.chdir(f"{gurusdk_root}/modules")
|
|
changed_module_path = (
|
|
f"{gurusdk_root}/modules/{repo_name}-{curren_resolved_ref}"
|
|
)
|
|
os.rename(module_path, changed_module_path)
|
|
resolved_ref = curren_resolved_ref
|
|
module_path = changed_module_path
|
|
print("error: resolved_ref != curren_resolved_ref: fixed!!")
|
|
runtime_modules[module] = {
|
|
"git": giturl,
|
|
"ref": branch,
|
|
"resolved-ref": resolved_ref,
|
|
}
|
|
|
|
module_subpath = ""
|
|
if "path" in module_info:
|
|
module_subpath = f"/{module_info['path']}"
|
|
module_symlink = f"{runtime_pkg_dir}/{module}"
|
|
if os.path.islink(module_symlink):
|
|
os.unlink(module_symlink)
|
|
os.symlink(f"{module_path}{module_subpath}", module_symlink)
|
|
|
|
new_refs = set(refs)
|
|
new_refs.add(module)
|
|
print(f"{module_path}{module_subpath}")
|
|
gurusdk_get(
|
|
f"{module_path}{module_subpath}",
|
|
gurusdk_resolved_ref=resolved_ref,
|
|
refs=new_refs,
|
|
)
|
|
os.chdir(gurusdk_runtime_dir)
|
|
runtime_pubspec_file.write(f" {module}:\n")
|
|
runtime_pubspec_file.write(f" path: packages/{module}\n")
|
|
os.chdir(f"{gurusdk_root}/modules")
|
|
return runtime_modules
|
|
|
|
|
|
def is_gurusdk_dir(target_dir):
|
|
return (
|
|
os.path.isdir(target_dir)
|
|
and os.path.isdir(f"{target_dir}/guru_app")
|
|
and os.path.isdir(f"{target_dir}/guru_ui")
|
|
and os.path.isdir(f"{target_dir}/guru_activity")
|
|
and os.path.isdir(f"{target_dir}/showcase")
|
|
)
|
|
|
|
|
|
def gurusdk_get(target_dir, force=False, gurusdk_resolved_ref="", refs={}):
|
|
print("gurusdk_get: ", target_dir)
|
|
os.chdir(target_dir)
|
|
with open("gurusdk.yaml", "r") as file:
|
|
config = yaml.safe_load(file)
|
|
with open("pubspec.yaml", "r") as file:
|
|
pubspec_config = yaml.safe_load(file)
|
|
|
|
pubname = pubspec_config["name"]
|
|
app = pubname
|
|
is_guru_lib = pubspec_config.get("gurulib", False)
|
|
if is_guru_lib:
|
|
runtime_ref_name = f"{pubname}_gurusdk"
|
|
compiler_ref_name = f"{pubname}_gurusdk_compiler"
|
|
else:
|
|
runtime_ref_name = "gurusdk"
|
|
compiler_ref_name = "gurusdk_compiler"
|
|
|
|
if gurusdk_resolved_ref != "":
|
|
app = f"{pubname}-{gurusdk_resolved_ref}"
|
|
|
|
gurusdk_root = get_gurusdk_root()
|
|
gurusdk_integrated_root = get_gurusdk_integrated_dir(app)
|
|
if not os.path.exists(gurusdk_integrated_root):
|
|
os.makedirs(gurusdk_integrated_root)
|
|
|
|
if local is not None and is_gurusdk_dir(local):
|
|
print(f"use local gurusdk:{local}")
|
|
version = "local"
|
|
gurusdk_version_dir = local
|
|
else:
|
|
version = config["guru_sdk"]
|
|
gurusdk_version_dir = gurusdk_download(version, force=force)
|
|
|
|
gurusdk_runtime_dir = get_gurusdk_runtime_dir(app)
|
|
gurusdk_compiler_dir = get_gurusdk_compiler_dir(app)
|
|
|
|
runtime_lock = {}
|
|
if os.path.exists(f"{gurusdk_runtime_dir}/gurusdk.lock"):
|
|
with open(f"{gurusdk_runtime_dir}/gurusdk.lock", "r") as file:
|
|
runtime_lock.update(yaml.safe_load(file))
|
|
force = force or (runtime_lock.get("guru_sdk", version) != version)
|
|
runtime_lock = {"guru_sdk": version}
|
|
print(f"gurusdk_get {force}")
|
|
if force or not os.path.exists(f"{gurusdk_runtime_dir}/pubspec.yaml"):
|
|
os.chdir(gurusdk_integrated_root)
|
|
if os.path.exists(gurusdk_runtime_dir):
|
|
shutil.rmtree(gurusdk_runtime_dir)
|
|
cmdrun("flutter create --template=package gurusdk")
|
|
os.chdir(gurusdk_runtime_dir)
|
|
if os.path.islink(version):
|
|
os.unlink(version)
|
|
if version == "local":
|
|
os.symlink(local, version)
|
|
else:
|
|
os.symlink(f"{gurusdk_root}/{version}", version)
|
|
os.chdir(target_dir)
|
|
|
|
if force or not os.path.exists(f"{gurusdk_compiler_dir}/pubspec.yaml"):
|
|
os.chdir(gurusdk_integrated_root)
|
|
if os.path.exists(gurusdk_compiler_dir):
|
|
shutil.rmtree(gurusdk_compiler_dir)
|
|
cmdrun("flutter create --template=package gurusdk_compiler")
|
|
|
|
os.chdir(gurusdk_compiler_dir)
|
|
if os.path.islink(version):
|
|
os.unlink(version)
|
|
if version == "local":
|
|
os.symlink(local, version)
|
|
else:
|
|
os.symlink(f"{gurusdk_root}/{version}", version)
|
|
os.chdir(target_dir)
|
|
|
|
compiler_bin_dir = f"{gurusdk_compiler_dir}/bin"
|
|
if not os.path.exists(compiler_bin_dir):
|
|
os.makedirs(compiler_bin_dir)
|
|
|
|
if os.path.exists(f"{gurusdk_runtime_dir}/pubspec.yaml"):
|
|
os.remove(f"{gurusdk_runtime_dir}/pubspec.yaml")
|
|
|
|
if os.path.exists(f"{gurusdk_compiler_dir}/pubspec.yaml"):
|
|
os.remove(f"{gurusdk_compiler_dir}/pubspec.yaml")
|
|
cmdrun(
|
|
f"cp {gurusdk_version_dir}/pubspec_compiler.yaml {gurusdk_compiler_dir}/pubspec.yaml"
|
|
)
|
|
|
|
if os.path.exists(f"{gurusdk_runtime_dir}/build.yaml"):
|
|
os.remove(f"{gurusdk_runtime_dir}/build.yaml")
|
|
cmdrun(f"cp {gurusdk_version_dir}/build.yaml {gurusdk_compiler_dir}/build.yaml")
|
|
|
|
supported_packages = {}
|
|
pkg_dirs = search_pkg_dirs(gurusdk_version_dir)
|
|
|
|
for dir in pkg_dirs:
|
|
package_name = os.path.basename(dir)
|
|
if package_name not in invalid_pkgs and package_name not in dev_pkgs:
|
|
supported_packages[package_name] = f"{version}/{dir}"
|
|
|
|
if version == "local":
|
|
origin_version = "0.0.0-local"
|
|
else:
|
|
origin_version = version.removeprefix("v")
|
|
|
|
integrate_packages = config["integrated"]
|
|
|
|
with open(f"{gurusdk_compiler_dir}/pubspec.yaml", "r") as file:
|
|
compiler_filedata = file.read()
|
|
|
|
if compiler_ref_name != "gurusdk_compiler":
|
|
compiler_filedata = re.sub(
|
|
"name: gurusdk_compiler", f"name: {compiler_ref_name}", compiler_filedata
|
|
)
|
|
|
|
compiler_filedata = re.sub(
|
|
"version: <gurusdk_version>", f"version: {origin_version}", compiler_filedata
|
|
)
|
|
compiler_filedata = re.sub("<gurusdk_version>", f"{version}", compiler_filedata)
|
|
|
|
for pkg in integrate_packages:
|
|
if pkg not in dev_pkgs:
|
|
continue
|
|
print(f"[compiler integrated] pkg: {pkg}")
|
|
compiler_filedata = re.sub(rf"#(.*{pkg}:\n)", rf" \1", compiler_filedata)
|
|
compiler_filedata = re.sub(
|
|
rf"#(.*path: {version}.*/{pkg}\n)", rf" \1", compiler_filedata
|
|
)
|
|
|
|
if pkg == "guru_splash_flutter":
|
|
if os.path.islink(f"{compiler_bin_dir}/create_splash.dart"):
|
|
os.unlink(f"{compiler_bin_dir}/create_splash.dart")
|
|
os.symlink(
|
|
f"{gurusdk_root}/{version}/guru_splash_flutter/bin/create.dart",
|
|
f"{compiler_bin_dir}/create_splash.dart",
|
|
)
|
|
else:
|
|
os.remove(f"{compiler_bin_dir}/create_splash.dart")
|
|
|
|
with open(f"{gurusdk_compiler_dir}/pubspec.yaml", "w") as file:
|
|
file.write(compiler_filedata)
|
|
|
|
os.chdir(gurusdk_runtime_dir)
|
|
|
|
with open(f"{gurusdk_version_dir}/pubspec_runtime.yaml", "r") as file:
|
|
lines = file.readlines()
|
|
with open(f"{gurusdk_runtime_dir}/pubspec.yaml", "w") as runtime_pubspec_file:
|
|
for line in lines:
|
|
if line == "name: gurusdk\n":
|
|
runtime_pubspec_file.write(f"name: {runtime_ref_name}\n")
|
|
elif line == "version: <gurusdk_version>\n":
|
|
runtime_pubspec_file.write(f"version: {origin_version}\n")
|
|
elif line == "######## GURU SDK DEPENDENCIES BEGIN ########\n":
|
|
runtime_pubspec_file.write(f"{line}\n")
|
|
for dir in pkg_dirs:
|
|
package_name = os.path.basename(dir)
|
|
if (
|
|
package_name in integrate_packages
|
|
and package_name not in invalid_pkgs
|
|
and package_name not in dev_pkgs
|
|
):
|
|
runtime_pubspec_file.write(f" {package_name}:\n")
|
|
runtime_pubspec_file.write(f" path: {version}/{dir}\n")
|
|
if "modules" in config:
|
|
runtime_lock["modules"] = import_modules(
|
|
app,
|
|
config["modules"],
|
|
runtime_pubspec_file,
|
|
runtime_lock.get("modules", {}),
|
|
refs,
|
|
)
|
|
else:
|
|
runtime_pubspec_file.write(line)
|
|
|
|
with open(f"{gurusdk_runtime_dir}/gurusdk.lock", "w") as file:
|
|
yaml.dump(runtime_lock, file)
|
|
|
|
print(target_dir)
|
|
os.chdir(target_dir)
|
|
if os.path.islink(f".gurusdk"):
|
|
os.unlink(f".gurusdk")
|
|
if os.path.islink(f".gurusdk_compiler"):
|
|
os.unlink(f".gurusdk_compiler")
|
|
|
|
os.symlink(f"{gurusdk_runtime_dir}", f".gurusdk")
|
|
os.symlink(f"{gurusdk_compiler_dir}", f".gurusdk_compiler")
|
|
|
|
runtime_cmd = f'dart pub add \'{runtime_ref_name}:{{"path":"./.gurusdk"}}\''
|
|
if runtime_ref_name not in pubspec_config["dependencies"]:
|
|
os.system(runtime_cmd)
|
|
|
|
compiler_cmd = (
|
|
f'dart pub add \'dev:{compiler_ref_name}:{{"path":"./.gurusdk_compiler"}}\''
|
|
)
|
|
if compiler_ref_name not in pubspec_config["dev_dependencies"]:
|
|
os.system(compiler_cmd)
|
|
|
|
def gurusdk_dumprefs():
|
|
os.chdir(current_dir)
|
|
with open("gurusdk.yaml", "r") as file:
|
|
config = yaml.safe_load(file)
|
|
with open("pubspec.yaml", "r") as file:
|
|
pubspec_config = yaml.safe_load(file)
|
|
|
|
pubname = pubspec_config["name"]
|
|
app = pubname
|
|
version = config["guru_sdk"]
|
|
gurusdk_root = get_gurusdk_root()
|
|
gurusdk_runtime_dir = get_gurusdk_runtime_dir(app)
|
|
gurusdk_version_dir = f"{gurusdk_root}/{version}"
|
|
|
|
os.system("echo '\n============== gurusdk.lock =============='")
|
|
os.system(f"cat {gurusdk_runtime_dir}/gurusdk.lock")
|
|
os.system(f"echo '\n============== sdk_commit({version}) =============='")
|
|
os.system(f"cat {gurusdk_version_dir}/sdk_commit")
|
|
os.system("echo '\n============== .gurusdk =============='")
|
|
os.system(f"cat {gurusdk_version_dir}/.gurusdk")
|
|
|
|
def cmdrun(command, loggable=True):
|
|
try:
|
|
if loggable:
|
|
print(f"run: {command}")
|
|
result = subprocess.run(
|
|
command, shell=True, check=True, text=True, capture_output=True
|
|
)
|
|
return result.stdout.strip().split("\n")
|
|
except subprocess.CalledProcessError as e:
|
|
if loggable:
|
|
print(f"Error: {e}")
|
|
return []
|
|
|
|
|
|
def batch_cmdrun(commands, loggable=True):
|
|
try:
|
|
for cmd in commands:
|
|
if loggable:
|
|
print(f"run: {cmd}")
|
|
subprocess.run(cmd, shell=True, check=True, text=True, capture_output=True)
|
|
return True
|
|
except subprocess.CalledProcessError as e:
|
|
if loggable:
|
|
print(f"Error: {e}")
|
|
return False
|
|
|
|
def gurusdk_locked_get(target_dir, force=False):
|
|
lock_path = get_guru_dir() + "/.gurusdk_lock"
|
|
|
|
lock = FileLock(lock_path, timeout=300)
|
|
try:
|
|
with lock.acquire():
|
|
gurusdk_get(target_dir, force=force)
|
|
except Timeout:
|
|
print("lock acquire timeout")
|
|
except Exception as e:
|
|
print(f"lock acquire error: {e}")
|
|
|
|
if __name__ == "__main__":
|
|
parser = argparse.ArgumentParser(description="Process some integers.")
|
|
parser.add_argument("action", type=str, help="action")
|
|
parser.add_argument("version", nargs="?", type=str, help="checksum version")
|
|
parser.add_argument("--sdk", type=str, help="flutter sdk path")
|
|
parser.add_argument("--local", type=str, help="local path")
|
|
parser.add_argument("--force", action="store_true", help="force")
|
|
|
|
args = parser.parse_args()
|
|
flutter_sdk = args.sdk
|
|
force = args.force
|
|
local = args.local
|
|
|
|
if flutter_sdk:
|
|
print(f"flutter sdk: {flutter_sdk}")
|
|
os.environ["PATH"] = f"{flutter_sdk}:{os.environ['PATH']}"
|
|
|
|
if args.action == "get":
|
|
gurusdk_locked_get(current_dir, force=force)
|
|
elif args.action == "snapshot" and args.version is not None:
|
|
gurusdk_snapshot(args.version, current_dir)
|
|
elif args.action == "update":
|
|
gurusdk_update()
|
|
elif args.action == "download":
|
|
gurusdk_download(args.version, force=True)
|
|
elif args.action == "publish":
|
|
gurusdk_publish()
|
|
elif args.action == "dir":
|
|
gurusdk_dir()
|
|
elif args.action == "dumprefs":
|
|
gurusdk_dumprefs()
|