import re
from common.git import Git, clone_gitproject
-from common.tempbuildpkg import TempBuildService, ProjectRepository
+from common.tempbuildpkg import ProjectBuildService, ProjectRepository
from common.tempbuildpkg import BuildData, RepoConf
from common.buildtrigger import trigger_info, trigger_next
from testprojects.prerelease import PreRelease, PreRelease2
+from testprojects.prerelease import get_prerelease_project_name
def create(prerelease, bservice, git_project):
"""Create pre-release OBS project."""
exit(1)
mygit = Git(prjdir)
- prerelease.create(bservice, mygit)
+ prerelease.create(mygit)
-def cleanup(prerelease, bservice):
+def cleanup(prerelease):
"""Remove pre-release OBS project."""
- bservice.cleanup()
- print "OBS Project %s deleted" % prerelease.obs_project
+ prerelease.cleanup()
- reviewrepo_paths = prerelease.get_published_repo(os.getenv("PATH_BASEDIR"))
-
- if reviewrepo_paths:
- for repodir in reviewrepo_paths:
- print "Removing temporary repo: %s" % repodir
- os.system("rm -rf %s" %repodir)
- else:
- print "WARN: Temporary repo doesn't exist!"
+ print "OBS Project %s deleted" % prerelease.obs_project
-def create_images(project, prerelease):
+def create_images(prerelease):
"""Create images using live prerelease repository."""
linked, depended = prerelease.get_parent_project()
server_conf['REPO_PUB_BASE_URL'] = os.getenv('REPO_PUB_BASE_URL')
server_conf['LIVEREPO_PUB_BASE_URL'] = os.getenv('LIVEREPO_PUB_BASE_URL')
- repo = ProjectRepository(project, repo_conf = repo_config,
+ repo = ProjectRepository(prerelease.obs_project, repo_conf = repo_config,
server_conf = server_conf)
# Fill build data
url_dict = {}
for obs_project in linked + depended:
url_dict[repo_config.get_name(obs_project)] = \
- repo.get_latest_repo_pub_url(obs_project)
+ repo.get_latest_repo_pub_url(obs_project)
new_repo_line = "repo --name=prerelease --baseurl=%s --save "\
- "--ssl_verify=no --priority 1" % repo.get_live_repo_pub_url()
+ "--ssl_verify=no --priority 1" % repo.get_live_repo_pub_url()
for ksi in ks_info.keys():
new_ks_lines = []
obs_api = os.getenv("OBS_API_URL")
obs_user = os.getenv("OBS_API_USERNAME")
obs_passwd = os.getenv("OBS_API_PASSWD")
- git_project = os.getenv("GIT_PROJECT")
-
- prerelease = PreRelease(content['OBS_REQ_PRJ'], obs_user,
- content['GIT_TAG'], git_project)
- project = prerelease.obs_project_name()
- bservice = TempBuildService(project, obs_api, obs_user, obs_passwd)
+ obs_target_prj = content.get('OBS_REQ_PRJ')
+ git_project = content.get("GIT_PROJECT")
+ git_tag = content.get("GIT_TAG")
+
+ # if no project in trigger, then it is triggered by Gerrit Event
+ if 'project' not in content.keys():
+ project = get_prerelease_project_name(obs_target_prj,
+ obs_user,
+ git_tag)
+ else:
+ project = content['project']
+ projectbuild = ProjectBuildService(project, obs_api,
+ obs_user, obs_passwd)
if action == 'create':
- create(prerelease, bservice, git_project)
+ prerelease = PreRelease(obs_target_prj, obs_user,
+ git_tag, git_project, projectbuild)
+ create(prerelease)
elif action == 'cleanup':
- cleanup(prerelease, bservice)
+ prerelease = PreRelease(obs_target_prj, obs_user,
+ git_tag, git_project, projectbuild)
+ cleanup(prerelease)
elif action == 'create_images':
- prerelease = PreRelease2(project, bservice)
- create_images(project, prerelease)
+ prerelease = PreRelease2(project, projectbuild)
+ create_images(prerelease)
else:
print "Not support method of Pre-release jobs"
import os
import time
import re
-from xml.etree import cElementTree as ET
+#Define the prerelease name:
+# home:<user_id>:prerelease:<origin_target_obs_project>:<tag_time_stampe>
+#
+
+def get_prerelease_project_name(obs_target_prj, obs_user,
+ git_tag_name):
+ """ get the prerelease project name on OBS from gerrit event
+ parameter """
+ return "home:%s:prerelease:%s:%s" %(
+ obs_user,
+ obs_target_prj,
+ os.path.basename(git_tag_name)
+ )
+
+def get_info_from_prerelease_name(prerelease_project_name):
+ """ return user_id, target_project, tag_time_stamp """
+ match = re.match("home:(.*):prerelease:(.*):([\.\w-]*)",
+ prerelease_project_name)
+ if not match:
+ raise Exception, "Ivalid project name found, %s" %prerelease_project_name
+
+ return match.group(1), match.group(2), match.group(3)
class PreRelease:
- """pre-release project class"""
- def __init__(self, obs_target_prj, obs_user, git_tag_name, git_project_name):
+ """pre-release project class, this class includes the operation of OBS
+ throught proejctbuild(buildservice) and the repo info etc"""
+
+ def __init__(self, obs_target_prj, obs_user, git_tag_name,
+ git_project_name, projectbuild):
self.target_project = obs_target_prj
self.user = obs_user
self.git_tag = git_tag_name
self.git_project = git_project_name
self.tag_time_stamp = os.path.basename(self.git_tag)
- self.obs_project = "home:%s:prerelease:%s:%s" %(
- self.user,
- self.target_project,
- self.tag_time_stamp)
+
+ self.obs_project = get_prerelease_project_name(obs_target_prj,
+ obs_user,
+ git_tag_name)
+
+ self.projectbuild = projectbuild
def obs_project_name(self):
return self.obs_project
- def get_published_repo(self, repo_path_base):
- """ Search publised repository, which releated with this sr
- return is a list.
- """
- ret_list = []
- # TODO: hardcode: pre-release
- reviewrepo_base = os.path.join(repo_path_base,'pre-release')
- if os.path.isdir(reviewrepo_base):
- for dir_name in os.listdir(reviewrepo_base):
- if dir_name.endswith("%s" %self.tag_time_stamp):
- ret_list.append(os.path.join(reviewrepo_base, dir_name))
-
- return ret_list
+ def cleanup(self):
+ self.projectbuild.cleanup()
- def create(self, bs, git):
+ def create(self, git):
git.checkout(self.git_tag)
- if bs.bs.isNewProject(self.obs_project):
+ if projectbuild.bs.isNewProject(self.obs_project):
os.system("gbs rb -B %s -T %s %s" %(self.target_project,
self.obs_project,
git.path))
self.target_project,
self.git_project,
self.git_tag)
- bs.linkbuild_localdep(desp = project_info)
+ projectbuild.linkbuild_localdep(desp = project_info)
else:
os.system("gbs rb -T %s %s" %(self.obs_project,
git.path))
time.sleep(2)
try:
- status = bs.get_repostatus()
+ status = projectbuild.get_repostatus()
print status
except:
print "WARN: did get any status from OBS project"
-class PreRelease2(PreRelease):
- """pre-release project class for repo maker"""
- def __init__(self, obs_project, packagebuild):
- match = re.match("home:(.*):prerelease:(.*):([\.\w-]*)", obs_project)
- if not match:
- raise Exception, "Ivalid project name found, %s" %obs_project
-
- self.packagebuild = packagebuild
- self.user = match.group(1)
- self.target_project = match.group(2)
-
- PreRelease.__init__(self, self.target_project, self.user, '', '')
-
- self.obs_project = obs_project
- self.tag_time_stamp = match.group(3)
-
- self.update_git_info()
-
def get_parent_project(self, repo_category = 'standard'):
- return self.packagebuild.bs.get_parent_project(self.obs_project,
+ return self.projectbuild.bs.get_parent_project(self.obs_project,
repo_category)
def get_available_archs(self, repo_category = 'standard'):
""" return the archs with repo published """
avail_arch = []
- archs = self.packagebuild.bs.get_project_arch(self.obs_project,
+ archs = self.projectbuild.bs.get_project_arch(self.obs_project,
repo_category)
- status = self.packagebuild.get_repostatus()
+ status = self.projectbuild.get_repostatus()
for arch in archs:
if status["%s/%s" %(repo_category, arch)] == "published":
avail_arch.append(arch)
return avail_arch
+class PreRelease2(PreRelease):
+ """pre-release project class with obs_project as init parameter """
+
+ def __init__(self, obs_project, projectbuild):
+ self.user, self.target_project, self.tag_time_stamp = \
+ get_info_from_prerelease_name(obs_project)
+
+ PreRelease.__init__(self, self.target_project, self.user,
+ '', '', projectbuild)
+
+ self.obs_project = obs_project
+
+ self.update_git_info()
+
def update_git_info(self):
- desp = self.packagebuild.bs.get_project_desp(self.obs_project)
+ desp = self.projectbuild.bs.get_project_desp(self.obs_project)
if not desp:
raise Exception, "Error: No project description found"
self.git_tag = line.split(':')[1].strip()
elif line.startswith('GIT_PROJECT'):
self.git_project = line.split(':')[1].strip()
-
- def repo_define(self, event_fields, server_conf, repos_conf):
- import yaml
-
- REPOCONF_TEMPLATE="""
- Name: %(name)s
- PartOf: "review"
- TopLevel: %(workdir)s/%(package)s
- Location: %(workdir)s/%(package)s/repos/%(sandbox_repo)s/
- Project: %(project)s
- AddRepos: %(addrepos)s
- Target: %(target)s
- SandboxOf: %(sandboxof)s
- SnapshotDir: %(path_builds)s/pre-release/
- Release: "%(release)s"
- ReleaseID: "%(releaseid)s"
- Architectures: %(arch)s
- """
- repo = event_fields["repo"]
- path_workdir = server_conf.workdir
- path_snapshots = server_conf.builds
-
- linked_project, depend_project = self.bs.get_parent_project(self.obs_project, repo)
- sandbox_repo_def = repos_conf.get_repo(self.target_project)
-
- if not sandbox_repo_def:
- return ""
-
- if depend_project:
- # FIXME: only care the first depend_project
- depend_repo_def = repos_conf.get_repo(depend_project[0])
- release_id = self.get_repo_id(extr_repo = depend_repo_def)
- else:
- release_id = ''
-
- REPO_CONF_STR = REPOCONF_TEMPLATE %{
- "name": self.obs_project.replace(":","-"),
- "workdir": path_workdir,
- "package": self.tag_time_stamp,
- "sandboxof": self.target_project,
- "sandbox_repo": os.path.basename(sandbox_repo_def['Location']),
- "project": self.obs_project,
- "target": repo,
- "path_builds": path_snapshots,
- "release": self.tag_time_stamp,
- "releaseid": release_id,
- "arch":["ia32"],
- "addrepos": depend_project
- }
- print REPO_CONF_STR
- return yaml.load(REPO_CONF_STR)
projects / services / jenkins-scripts.git / commitdiff