def main(): # parse arguments args = parse_command_line(sys.argv[1:]) if args.publish: if args.git_credential: repo_operator = RepoOperator(args.git_credential) else: print "Error occurs when get crendtail in update submodule" sys.exit(1) else: repo_operator = RepoOperator(args.git_credential) if os.path.isdir(args.build_dir): for filename in os.listdir(args.build_dir): try: repo_dir = os.path.join(args.build_dir, filename) submodules_list = subModulesExist(repo_dir, repo_operator) if submodules_list is None: continue #git pull is used to get the lastest code to make sure push successfully test_info = repo_operator.git_pull(repo_dir, "origin", "master") revert_commit_for_submodules_update(repo_dir, repo_operator, args.version) if args.publish: print "start to publish revert update submodule in {0}".format( repo_dir) commit_message = "revert update submodule for new commit {}".format( args.version) repo_operator.push_repo_changes(repo_dir, commit_message) except Exception, e: print "Failed to revert update submodule of {0} due to {1}".format( filename, e) sys.exit(1)
def __init__(self, source, dest, branch, builddir, git_credentials, force=False, jobs=1): """ Generate a new manifest for new branch according to a source manifest file. _source_manifest_file: the path of source manifest _dest_manifest_file: the path of new manifest _new_branch: the new branch name _force: overwrite the destination if it exists. _git_credentials: url, credentials pair for the access to github repos. _builddir: the destination for checked out repositories. _jobs: number of parallel jobs to run. The number is related to the compute architecture, multi-core processors... :return: None """ self._source_manifest_file = source self._dest_manifest_file = dest self._new_branch = branch self._git_credentials = git_credentials self._manifest = None self._force = force self._builddir = builddir self._jobs = jobs self.initiate_manifest() self.repo_operator = RepoOperator(git_credentials) self.check_builddir()
def __init__(self, manifest_path, builddir, force=False, git_credentials=None, jobs=1, actions=[], branch_name=None, tag_name=None): """ __force - Overwrite a directory if it exists __git_credential - url, credentials pair for the access to github repos __manifest - Repository manifest contents __builddir - Destination for checked out repositories __jobs - Number of parallel jobs to run __actions -Supported actions :return: """ self._force = force self._git_credentials = git_credentials self._builddir = builddir self._manifest = None self.handle_manifest(manifest_path) self._jobs = jobs self.actions = [] for action in actions: self.add_action(action) self._branch_name = branch_name self._tag_name = tag_name self.repo_operator = RepoOperator(self._git_credentials)
def main(): # parse arguments args = parse_command_line(sys.argv[1:]) if args.publish: if args.git_credential: repo_operator = RepoOperator(args.git_credential) else: print "If you want to publish the updated changelog, please specify the git-credential. Exiting now..." sys.exit(1) if os.path.isdir(args.build_dir): for filename in os.listdir(args.build_dir): try: repo_dir = os.path.join(args.build_dir, filename) updater = ChangelogUpdater(repo_dir, args.version) if updater.update_changelog(message=args.message): if args.publish: commit_message = "update changelog for new release {0}".format( args.version) repo_operator.push_repo_changes( repo_dir, commit_message) except Exception, e: print "Failed to update changelog of {0} due to {1}".format( filename, e) sys.exit(1)
def __init__(self): """ __repo - the repository url being updated in the manifest __branch - the branch name associated with __repo __sliced_branch - the branch name sliced at any forward slashes __commit - The commit id associated with the __repo and __branch that we want to update __manifest_repository_url - the repository url the points to the collection of manifest files __manifest_file - the desired manifest file to update which resides in __manifest_repository_url __cleanup_directories - the path/name of directories created are appended here for cleanup in task_cleanup __git_credentials - url, credentials pair for the access to github repos quiet - used for testing to minimize text written to a terminal repo_operator - Class instance of RepoOperator :return: None """ self.__repo = None self.__branch = None self.__sliced_branch = None self.__commit = None self.__manifest_repository_url = None self.__manifest_file = None self.__cleanup_directories = [] self.__git_credentials = None self.__updated_manifest = None self.__dryrun = False self.quiet = False self.repo_operator = RepoOperator()
def __init__(self, dest, branch, builddir, git_credential=None, force=False, jobs=1): """ Generate a new manifest according to the manifest sample: manifest.json _dest_manifest_file: the path of new manifest _branch: the branch name _force: overwrite the destination if it exists. _builddir: the destination for checked out repositories. _jobs: number of parallel jobs to run. The number is related to the compute architecture, multi-core processors... :return: None """ self._dest_manifest_file = dest self._branch = branch self._builddir = builddir self._force = force self._jobs = jobs self._manifest = Manifest.instance_of_sample() self.repo_operator = RepoOperator(git_credential) self.check_builddir()
def main(): # parse arguments args = parse_command_line(sys.argv[1:]) if args.publish: if args.git_credential: repo_operator = RepoOperator(args.git_credential) else: print "If you want to publish the updated changelog, please specify the git-credential. Exiting now..." sys.exit(1) if os.path.isdir(args.build_dir): for filename in os.listdir(args.build_dir): try: repo_dir = os.path.join(args.build_dir, filename) changelog_updater = ChangelogUpdater(repo_dir, args.version) npm_package_updater = NPMVersionUpdater(repo_dir, args.version) package_updated = npm_package_updater.update_package_json() changelog_updated = changelog_updater.update_changelog(message = args.message) if changelog_updated or package_updated: if args.publish: print "start to push changes in {0}".format(repo_dir) commit_message = "jump version for new release {0}".format(args.version) repo_operator.push_repo_changes(repo_dir, commit_message) except Exception,e: print "Failed to jump version of {0} due to {1}".format(filename, e) sys.exit(1)
def __init__(self, dest, builddir, git_credential=None, force=False, jobs=1): self._jenkins_author = config.gitbit_identity["username"] self._dest_manifest_file = dest self._builddir = builddir self._force = force self._jobs = jobs self._manifest = Manifest.instance_of_sample() self.repo_operator = RepoOperator(git_credential) self.check_builddir()
def __init__(self, repo_dir, version): """ The module updates debian/changelog under the directory of repository _repo_dir: the directory of the repository _version: the new version which is going to be updated to changelog """ self._repo_dir = repo_dir self._version = version self.repo_operator = RepoOperator()
def main(): # parse arguments args = parse_command_line(sys.argv[1:]) try: manifest = Manifest(args.manifest) manifest.validate_manifest() except KeyError as error: print "Failed to create a Manifest instance for the manifest file {0} \nERROR:\n{1}"\ .format(args.manifest, error.message) sys.exit(1) if args.publish: if args.git_credential: repo_operator = RepoOperator(args.git_credential) else: print "Error occurs when get crendtail in update submodule" sys.exit(1) else: repo_operator = RepoOperator(args.git_credential) if os.path.isdir(args.build_dir): print args.build_dir for filename in os.listdir(args.build_dir): try: repo_dir = os.path.join(args.build_dir, filename) repo_operator.submodule_init(repo_dir) repo_operator.submodule_update(repo_dir) submodules_list = repo_operator.get_current_submodule(repo_dir) if len(submodules_list) == 0: continue for key in submodules_list: commit_id = get_manifest_commit_id(key, manifest) if commit_id != None: sub_dir = repo_dir + "/" + key repo_operator.checkout_to_commit(sub_dir, commit_id) if args.publish: print "start to publish update submodule in {0}".format( repo_dir) commit_message = "update submodule for new commit {0}".format( args.version) repo_operator.push_repo_changes(repo_dir, commit_message) except Exception, e: print "Failed to update submodule of {0} due to {1}".format( filename, e) sys.exit(1)
def __init__(self, repo_dir): """ This module compute the version of a repository The version for candidate release: {release_version}-{build_version} The release version is parsed from debian/changelog The samll version is consist of the commit hash and commit date of manifest repository :return:None """ self._repo_dir = repo_dir self.repo_operator = RepoOperator() self._repo_name = self.get_repo_name()
def __init__(self, repo_dir): """ This module compute the version of a repository The version for candidate release: {big-version}~{version-stage}-{small-version} The big version is parsed from debian/changelog The version-stage is devel if branch is master; or rc if branch if not master The samll version is consist of the commit hash and commit date of manifest repository :return:None """ self._repo_dir = repo_dir self.repo_operator = RepoOperator() self._repo_name = self.get_repo_name()
def __init__(self, manifest_dir, builddir, is_official_release=False): """ Compute the version of each repository under builddir and update the debian/control with these versions __manifest_repo_dir - The directory of Repository manifest __builddir - Destination for checked out repositories __is_official_release - True if the official is official release :return: None """ self._builddir = builddir self._manifest_repo_dir = manifest_dir self._is_official_release = is_official_release self.repo_operator = RepoOperator()
def __init__(self, manifest_path, builddir): """ __force - Overwrite a directory if it exists __git_credential - url, credentials pair for the access to github repos __manifest - Repository manifest contents __builddir - Destination for checked out repositories __jobs - Number of parallel jobs to run __actions -Supported actions :return: """ self._force = False self._git_credentials = None self._builddir = builddir self._manifest = None self.handle_manifest(manifest_path) self._jobs = 1 self.actions = [] self.repo_operator = RepoOperator()
def main(): # parse arguments args = parse_command_line(sys.argv[1:]) generator = ManifestGenerator(args.source_manifest, args.dest_manifest, args.branch, args.builddir, args.git_credentials, jobs=args.jobs, force=args.force) try: generator.update_manifest() if args.force: generator.set_force(args.force) if args.publish: if args.git_credentials and args.publish_branch: repo_operator = RepoOperator(args.git_credentials) commit_message = "add a manifest file for new branch {0}".format( args.branch) repo_dir = os.path.dirname(args.dest_manifest) repo_operator.checkout_repo_branch(repo_dir, args.publish_branch) generator.generate_manifest() repo_operator.push_repo_changes(repo_dir, commit_message, push_all=True) else: print "Please specify the git-credential and publish-branch if you want to push the new manifest" sys.exit(1) else: generator.generate_manifest() except Exception, e: traceback.print_exc() print "Failed to generate new manifest for {0} due to \n{1}\nExiting now".format( args.branch, e) sys.exit(1)