def set_real_version(self):
path = os.path.join(self.path, "tmp")
try:
os.path.isfile(self.path + "/PKGBUILD")
output("source " + self.path +
"/PKGBUILD; type pkgver &> /dev/null")
except:
return
exit_code = self._execute(f"""
mkdir -p ./tmp;
makepkg \
SRCDEST=./tmp \
--nobuild \
--nodeps \
--nocheck \
--nocolor \
--noconfirm \
--skipinteg; \
""")
shutil.rmtree(path)
if exit_code > 0:
self.errors.append("An error append when executing makepkg")
def _check_ssh_connection():
script = "ssh -i ./deploy_key -p %i -q %s@%s [[ -d %s ]] && echo 1 || echo 0" % (
conf.ssh_port, conf.ssh_user, conf.ssh_host, conf.ssh_path)
validate(error="ssh connection could not be established.",
target="ssh address",
valid=(output(script) is "1"))
def _check_git_branch():
branch = output("git rev-parse --abbrev-ref HEAD")
validate(
error="This program needs to be on master branch before to build.",
target="git repository",
valid=(branch == "master"))
def _get_schema(self, name):
schema = {}
is_package = False
lines = output("pacman -Si %s" % name).split("\n")
keys = {
"repository": "Repository",
"description": "Description",
"version": "Version",
"date": "Build Date",
}
for line in lines:
if is_package is False:
if line.startswith(keys["repository"]) and self._strip_key(line) == conf.db:
is_package = True
else:
for key in keys:
if line.startswith(keys[key]):
schema[key] = self._strip_key(line)
if key == "date":
parameters = schema[key].split(" ")
schema[key] = parameters[1] + " " + parameters[2] + " " + parameters[3]
if line == "":
is_package = False
return schema
def pull_main_repository(self):
if IS_DEVELOPMENT or update_disabled("bot"):
return
print("Updating repository bot:")
try:
output("git remote | grep upstream")
except:
self._execute(f"git remote add upstream {UPSTREAM_REPOSITORY}")
self._execute(
"git fetch upstream; "
"git pull --no-ff --no-commit -X theirs upstream master; "
"git reset HEAD README.md; "
"git checkout -- README.md; "
"git commit -m 'Core: Pull main repository project';")
print(" [ ✓ ] up to date")
def deploy(self):
if output(
"git branch -r --contains $(git log --pretty=format:'%h' -n 1) | sed s/^...//"
):
return
if remote_repository() and len(conf.updated) > 0:
self._deploy_ssh()
self._deploy_git()
def verify_dependencies(self):
self.depends = extract(self.path, "depends")
self.makedepends = extract(self.path, "makedepends")
self._dependencies = (self.depends + " " + self.makedepends).strip()
if self._dependencies == "":
return
for dependency in self._dependencies.split(" "):
try:
output("pacman -Sp '" + dependency + "' &>/dev/null")
continue
except:
if dependency not in conf.packages:
sys.exit(
"\nError: %s is not part of the official package and can't be found in pkg directory."
% dependency)
if dependency not in conf.updated:
repository.build_package(dependency, True)
def verify_dependencies(self):
redirect = False
self.depends = extract(self.path, "depends")
self.makedepends = extract(self.path, "makedepends")
self._dependencies = (self.depends + " " + self.makedepends).strip()
if self._dependencies == "":
return
for dependency in self._dependencies.split(" "):
try:
output("pacman -Sp '" + dependency + "' &>/dev/null")
continue
except:
redirect = False
if dependency not in conf.packages:
dependency = dependency.split(">")[0].split("<")[0]
if output(
"git ls-remote https://aur.archlinux.org/%s.git" %
dependency):
redirect = True
self._add_to_pkg(dependency)
else:
sys.exit(
"\nError: %s is not part of the official package and can't be found in pkg directory."
% dependency)
if redirect or dependency not in conf.updated:
if (len(conf.updated) > 0 and IS_TRAVIS):
return
print("Install missing dependencies before to build it.")
redirect = True
repository.build_package(dependency, True, self.is_testing)
if redirect is True and IS_TRAVIS is False:
self.separator()
def create(self):
if IS_DEVELOPMENT:
return
packages = output("pacman -Slq %s | sort" % conf.db)
if packages.startswith("error: repository"):
return
else:
packages = packages.split("\n")
for name in packages:
schema = self._get_schema(name)
description = schema["description"]
version = schema["version"]
date = schema["date"]
path = self._get_file_location(name, version)
for prefix in ["html", "markdown"]:
tr = getattr(self, prefix + "_table_tr")
tr = tr.replace("$path", path)
tr = tr.replace("$name", name)
tr = tr.replace("$date", date)
tr = tr.replace("$version", version)
if prefix == "markdown":
description = description.replace("\\", "\\\\")
description = description.replace("*", "\*")
description = description.replace("_", "\_")
description = description.replace("|", "\|")
tr = tr.replace("$description", description)
tbody = getattr(self, prefix + "_table_tbody")
setattr(self, prefix + "_table_tbody", tbody + tr)
# Create html mirror
if remote_repository():
self._move_to_mirror()
self._replace_html_variables()
self._compress()
# Creade README.md
if update_disabled("readme"):
return
self._move_to_root()
self._replace_markdown_variables()
self._commit_readme()
def _check_github_token():
valid = False
user = git_remote_path().split("/")[1]
response = output("curl -su %s:%s https://api.github.com/user" %
(user, conf.github_token))
content = json.loads(response)
if "login" in content:
valid = True
validate(
error=
"An error occured while trying to connect to your github repository with your encrypted token.\nPlease make sure that your token is working.",
target="github token api",
valid=valid)
def clean_mirror(self):
if not os.path.exists(f"{paths.mirror}/{conf.db}.db"):
return
database = output(f"pacman -Sl {conf.db}")
files = self._get_mirror_packages()
packages = []
for package in database.split("\n"):
split = package.split(" ")
packages.append(split[1] + "-" + split[2] + "-")
for fp in files:
if self._in_mirror(packages, fp) is False:
os.remove(paths.mirror + "/" + fp)
def clean_database(self):
in_directory = []
in_database = output("pacman -Slq %s | sort" % conf.db)
if in_database.startswith("error: repository"):
return
else:
in_database = in_database.split("\n")
for name in conf.packages:
directory = paths.pkg + "/" + name
try:
open(directory + "/PKGBUILD")
except FileNotFoundError:
continue
in_directory = in_directory + extract(directory,
"pkgname").split(" ")
os.chdir(paths.mirror)
useless_packages = set(in_database) - set(in_directory)
if len(useless_packages) == 0:
return
print("Remove packages in database:")
for name in (set(in_database) - set(in_directory)):
schema = self._get_schema(name)
path = name + "-" + schema["version"]
strict_execute(f"""
repo-remove \
--nocolor \
--remove \
{paths.mirror}/{conf.db}.db.tar.gz \
{name}
""")
def _get_schema(self, name):
schema = {}
is_package = False
path = paths.mirror + "/" + conf.db + ".db"
execute_quietly("cp %s /var/lib/pacman/sync/{conf.db}" % path)
try:
lines = output("pacman -Si %s" % name).split("\n")
except:
return
keys = {
"repository": "Repository",
"description": "Description",
"version": "Version",
"date": "Build Date",
}
for line in lines:
if is_package is False:
if line.startswith(keys["repository"]) and self._strip_key(
line) == conf.db:
is_package = True
else:
for key in keys:
if line.startswith(keys[key]):
schema[key] = self._strip_key(line)
if key == "date":
parameters = schema[key].split(" ")
schema[key] = parameters[1] + " " + parameters[
2] + " " + parameters[3]
if line == "":
is_package = False
return schema
def prepare_mirror(self):
remote = output("git ls-files " + paths.mirror +
" | awk -F / '{print $2}'").split("\n")
files = os.listdir(paths.mirror)
for f in ["validation_token", "packages_checked"]:
if f in files:
files.remove(f)
if len(files) != len(remote) or not remote_repository():
return
print(bold("Pull remote mirror directory files:"))
strict_execute(f"""
scp -i {paths.base}/deploy_key -P {conf.ssh_port} \
{conf.ssh_user}@{conf.ssh_host}:{conf.ssh_path}/* \
{paths.mirror}/;
ssh -i {paths.base}/deploy_key -p {conf.ssh_port} \
{conf.ssh_user}@{conf.ssh_host} \
touch {conf.ssh_path}/*;
""")
def title(text):
column = int(output("tput cols")) - 4
line = "── %s " % text.capitalize()
line += "─" * (column - len(text))
return bold(line)
def get_last_change(self, path):
last_change = output("git log -1 --format='%at' -- " + path)
timestamp = datetime.fromtimestamp(int(last_change))
return timestamp.strftime("%d %h %Y")