def run():
jenkins_project = args.projectName
jenkins_build_number = args.buildNumber
if not jenkins.find_if_build_is_green(jenkins_project,
jenkins_build_number):
print("Build #" + jenkins_build_number + " of '" + jenkins_project +
"' is not a green build.")
sys.exit(1)
repo_url = jenkins.find_github_repo_url_from_build(jenkins_project)
git = Git(WORKSPACE, repo_url)
commit_id = jenkins.find_commit_id_from_build(jenkins_project,
jenkins_build_number)
verbose("commit_id=" + commit_id)
repo_name = git.repo_name()
verbose("repo_name=" + repo_name)
git.clone()
verbose("Git repo '" + repo_name + "' cloned to " + WORKSPACE)
most_recent_tag = git.describe(commit_id)
verbose("Most recent release: " + most_recent_tag)
new_version_number = lib.read_user_preferred_version(
repo_name, most_recent_tag)
git.tag(commit_id, "release/" + new_version_number)
def sched_builder(self):
for project in sorted(Project.get_all(), key=lambda p: p.name):
if (project.name == ""):
continue
try:
log.msg("checking project: %s" % project.name)
if project.is_building():
log.msg("project %s still building, skip" % project.name)
continue
branch = "master"
git = Git(project)
if os.path.isdir(git.workdir):
git.checkout_branch(branch)
git.pull()
else:
git.clone(branch)
if not os.path.isdir(git.workdir):
continue
for remote_branch in git.branches(remote=True):
git.checkout_remote_branch(remote_branch.replace('origin/', ''))
for release in ('stable', 'testing', 'unstable'):
if project.last_tag(release) != git.last_tag(release):
try:
_, version = git.last_tag(release).split('_')
log.msg("new %s tag, building version: %s" % (release, version))
d = threads.deferToThread(self.send_job, project.name, branch, release, version)
except Exception, e:
log.msg("tag not parsed: %s:%s" % (project.name, git.last_tag(release)))
except Exception, e:
log.err(e)
def clone(self, url=None, to_path=None, branch=None):
Log.info(Status["STAT_GET_PACKAGE"] % url)
g = Git(to_path)
g.clone(url or self.github_url)
if branch:
g.checkout(branch)
return True
def test_describe_never_tagged_before(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
lib.call_and_exit_if_failed(
'git tag -a release/0.1.1 -m \'releasing version\'')
latest_tag = git.describe()
self.assertEqual(latest_tag, "0.1.1")
def run():
jenkins_project = args.projectName
jenkins_build_number = args.buildNumber
if not jenkins.find_if_build_is_green(jenkins_project, jenkins_build_number):
print "Build #" + jenkins_build_number + " of '" + jenkins_project + "' is not a green build."
sys.exit(1)
repo_url = jenkins.find_github_repo_url_from_build(jenkins_project)
git = Git(WORKSPACE, repo_url)
commit_id = jenkins.find_commit_id_from_build(jenkins_project, jenkins_build_number)
verbose("commit_id=" + commit_id)
repo_name = git.repo_name()
verbose("repo_name=" + repo_name)
git.clone()
verbose("Git repo '" + repo_name + "' cloned to " + WORKSPACE)
most_recent_tag = git.describe()
verbose("Most recent release: " + most_recent_tag)
new_version_number = lib.read_user_preferred_version(repo_name, most_recent_tag)
git.tag(commit_id, "release/" + new_version_number)
def test_update(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
self.assertTrue(os.path.exists(os.path.join(test_repo_dir, "ANOTHER_FILE.txt")) != 1)
os.chdir(test_repo_dir)
with open("ANOTHER_FILE.txt", "a") as the_file:
the_file.write("Another file")
lib.call_and_exit_if_failed("git add .")
lib.call_and_exit_if_failed('git commit -m "another commit"')
git.update()
self.assertTrue(os.path.exists(os.path.join(test_repo_dir, "ANOTHER_FILE.txt")) == 1)
def test_update(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
self.assertTrue(
os.path.exists(os.path.join(test_repo_dir, "ANOTHER_FILE.txt")) !=
1)
os.chdir(test_repo_dir)
with open('ANOTHER_FILE.txt', 'a') as the_file:
the_file.write('Another file')
lib.call_and_exit_if_failed('git add .')
lib.call_and_exit_if_failed('git commit -m "another commit"')
git.update()
self.assertTrue(
os.path.exists(os.path.join(test_repo_dir, "ANOTHER_FILE.txt")) ==
1)
def cloneOrCheckout(base_path, repo): git = Git() repo_path = os.path.join(base_path, repo['name']) print (repo_path) try: os.chdir(repo_path) except OSError: os.chdir(base_path) git.clone(repo['base_url'] + repo['name']) os.chdir(repo_path) cloned = True finally: git.fetch() git.checkout(repo['branch']) os.chdir(base_path)
def cli(debug:bool, update:bool):
""" do the needful """
setup_logging(debug, logger)
hangnail_data = []
try:
if os.path.exists(DATA_FILENAME):
hangnail_data += json.load(open(DATA_FILENAME,'r'))
except Exception as error_message:
logger.error("Couldn't load {}, {}", DATA_FILENAME, error_message)
# print(dir(repo))
if update:
if not os.path.exists(SOURCEREPO):
logger.error("Can't find source repo: {}", SOURCEREPO)
g = Git()
g.clone(REMOTE_URL, SOURCEREPO)
else:
g = Git(SOURCEREPO)
g.pull()
if not os.path.exists(SIGNATURE_DIR):
logger.error("Can't find signatures dir: {}", SIGNATURE_DIR)
sys.exit(1)
seen_keys = []
for filename in os.listdir(SIGNATURE_DIR):
full_filename = os.path.join(SIGNATURE_DIR,filename)
signature = handle_signature_file(full_filename)
logger.debug(signature)
for key in signature:
if key not in seen_keys:
seen_keys.append(key)
if signature not in hangnail_data:
hangnail_data.append(signature)
logger.debug("Keys seen: {}", seen_keys)
if update:
logger.info("Writing file...")
with open(DATA_FILENAME, 'w') as file_handle:
json.dump(obj=hangnail_data,fp=file_handle)
def _updateRepo(self, reponame):
remotepath = self.repos.get(reponame, "path")
submodules = self.repos.get(reponame,
"submodules") if self.repos.has_option(
reponame, "submodules") else False
localpath = os.path.join(self.repodir, reponame)
os.umask(0o007) # create repo content not readable to others
if not os.path.isdir(localpath):
g = Git()
g.clone(remotepath, localpath)
repo = Repo(localpath)
if submodules:
repo.git.submodule("init")
# not-working umask workaround
p = subprocess.Popen(["chmod", "g+w", localpath])
p.wait()
else:
repo = Repo(localpath)
try:
repo.git.update_index("--refresh")
except GitCommandError:
pass # it's fine, we'll reset
# We use wrapped API (direct git command calls) rather than calling semantic GitPython API.
# (e.g. repo.remotes.origin.pull() was replaced by repo.git.pull("origin"))
repo.git.reset("--hard", "master")
#repo.git.clean("-f")
repo.git.pull("origin")
if submodules:
repo.git.submodule("init")
repo.git.submodule("foreach", "git", "fetch")
repo.git.submodule("update")
# now set correct group (same as build user)
usr = self.repos.get(reponame, "build_usr")
p = subprocess.Popen(["chgrp", usr, "-R", "-f", localpath])
p.wait()
return repo
def _updateRepo(self, reponame):
remotepath = self.repos.get(reponame, "path")
submodules = self.repos.get(reponame, "submodules") if self.repos.has_option(reponame, "submodules") else False
localpath = os.path.join(self.repodir, reponame)
os.umask(0o007) # create repo content not readable to others
if not os.path.isdir(localpath):
g = Git()
g.clone(remotepath, localpath)
repo = Repo(localpath)
if submodules:
repo.git.submodule("init")
# not-working umask workaround
p = subprocess.Popen(["chmod", "g+w", localpath])
p.wait()
else:
repo = Repo(localpath)
try:
repo.git.update_index("--refresh")
except GitCommandError:
pass # it's fine, we'll reset
# We use wrapped API (direct git command calls) rather than calling semantic GitPython API.
# (e.g. repo.remotes.origin.pull() was replaced by repo.git.pull("origin"))
repo.git.reset("--hard", "master")
# repo.git.clean("-f")
repo.git.pull("origin")
if submodules:
repo.git.submodule("init")
repo.git.submodule("foreach", "git", "fetch")
repo.git.submodule("update")
# now set correct group (same as build user)
usr = self.repos.get(reponame, "build_usr")
p = subprocess.Popen(["chgrp", usr, "-R", localpath])
p.wait()
return repo
def sched_builder(self):
for project in sorted(Project.get_all(), key=lambda p: p.name):
if (project.name == ""):
continue
try:
log.msg("checking project: %s" % project.name)
if project.is_building():
log.msg("project %s still building, skip" % project.name)
continue
branch = "master"
git = Git(project)
if os.path.isdir(git.workdir):
git.checkout_branch(branch)
git.pull()
else:
git.clone(branch)
if not os.path.isdir(git.workdir):
continue
for remote_branch in git.branches(remote=True):
git.checkout_remote_branch(
remote_branch.replace('origin/', ''))
for release in ('stable', 'testing', 'unstable'):
if project.last_tag(release) != git.last_tag(release):
try:
_, version = git.last_tag(release).split('_')
log.msg("new %s tag, building version: %s" %
(release, version))
d = threads.deferToThread(self.send_job,
project.name, branch,
release, version)
except Exception, e:
log.msg("tag not parsed: %s:%s" %
(project.name, git.last_tag(release)))
except Exception, e:
log.err(e)
def init(ctx):
"""Run initial setup"""
VerboseLog('Running init()', ctx)
config_file = config_file_path()
Config = ConfigParser.ConfigParser()
if not config_exists():
VerboseLog('Initializing first set up.', ctx)
f = open(config_file, 'w+')
os.makedirs(dot_dir_path())
Config.add_section('options')
VerboseLog('Requesting user options for initial settings.', ctx)
value = click.prompt('GitHub user name', confirmation_prompt=True)
Config.set('options', 'gitname', value)
value = click.prompt('GitHub repo name', default='dotfiles')
Config.set('options', 'reponame', value)
Config.write(f)
f.close()
VerboseLog('Options set.', ctx)
VerboseLog('Cloning repo into $HOME/.dot/', ctx)
git = Git(home(), Conf('options', 'gitname'),
Conf('options', 'reponame'))
return_code = git.clone()
VerboseLog('git.clone() return_code was ' + str(return_code), ctx)
if return_code == 0:
click.secho(
'\ndot is initalized. Run `dot pull` to pull dotfiles,\nor `dot track [dotfile]` if you\'ve never\nused dot. Also see `dot --help`.\n',
fg='green')
else:
click.secho(
'\ndot could not pull your repo from GitHub.\nRun `dot clean` followed by `dot init`\nto start over.\n\n(You may want to check your prerequisites\nat https://github.com/kylefrost/dot-cli#prerequisites.)\n',
fg='red')
else:
VerboseLog('Is not initial set up.', ctx)
click.secho(
'You already set up dot. Run `dot config [option] [value]` to\nchange a config value, or edit '
+ config_file + '. To start\nover, run `dot clean`.\n',
fg='yellow')
def init(ctx):
"""Run initial setup"""
VerboseLog('Running init()', ctx)
config_file = config_file_path()
Config = ConfigParser.ConfigParser()
if not config_exists():
VerboseLog('Initializing first set up.', ctx)
f = open(config_file, 'w+')
os.makedirs(dot_dir_path())
Config.add_section('options')
VerboseLog('Requesting user options for initial settings.', ctx)
value = click.prompt('GitHub user name', confirmation_prompt=True)
Config.set('options', 'gitname', value)
value = click.prompt('GitHub repo name', default='dotfiles')
Config.set('options', 'reponame', value)
Config.write(f)
f.close()
VerboseLog('Options set.', ctx)
VerboseLog('Cloning repo into $HOME/.dot/', ctx)
git = Git(home(), Conf('options', 'gitname'), Conf('options', 'reponame'))
return_code = git.clone()
VerboseLog('git.clone() return_code was ' + str(return_code), ctx)
if return_code == 0:
click.secho('\ndot is initalized. Run `dot pull` to pull dotfiles,\nor `dot track [dotfile]` if you\'ve never\nused dot. Also see `dot --help`.\n', fg='green')
else:
click.secho('\ndot could not pull your repo from GitHub.\nRun `dot clean` followed by `dot init`\nto start over.\n\n(You may want to check your prerequisites\nat https://github.com/kylefrost/dot-cli#prerequisites.)\n', fg='red')
else:
VerboseLog('Is not initial set up.', ctx)
click.secho('You already set up dot. Run `dot config [option] [value]` to\nchange a config value, or edit ' + config_file + '. To start\nover, run `dot clean`.\n', fg='yellow')
def test_describe_never_tagged_before(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
latest_tag = git.describe()
self.assertEqual(latest_tag, "0.0.0")
def test_tag(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
git.tag(git.latest_commit_id(), "release/1.2.3")
tag_query = lib.call('git describe --abbrev=0 --match release/*')
self.assertEqual(tag_query.stdout.read().strip(), "release/1.2.3")
def cloneAll(destination='.'):
repos = GithubRepos()
for repoUrl in repos.repoUrls:
Git.clone(repoUrl, destination)
if os.path.exists(icons_dir):
# Clean up old work directory
print(f'Cleaning icons directory {icons_dir}')
shutil.rmtree(icons_dir)
print('Creating work directories')
if not os.path.exists(build_dir):
os.mkdir(build_dir)
if not os.path.exists(icons_dir):
os.mkdir(icons_dir)
if not os.path.exists(md_git_dir):
print(f'Cloning MaterialDesign repository into {build_dir}')
repo = Git(build_dir)
result = repo.clone(MDI_REPO)
else:
print(f'Pulling changes from MaterialDesign repository into {md_git_dir}')
repo = Repo(md_git_dir)
remote = repo.remotes[0]
remote.pull()
svg_files_count = len(fnmatch.filter(os.listdir(svg_path), '*.svg'))
print(f'Found {svg_files_count} files in {svg_path}')
# Create bitmaps
for svg_file in glob.iglob(os.path.join(svg_path, '*.svg')):
file_name = Path(os.path.basename(svg_file)).stem
print(f'Processing {file_name}.svg', end='')
# Load SVG file and save as PNG for PIL
def clone_git_repo(url, local_path):
git_repo = Git(local_path)
git_repo.clone(url)
class Project():
def __init__(self):
self.tree = ElementTree();
self.git = Git()
if not os.path.exists(PROJECT_CONFIG_PATH):
os.mkdir(PROJECT_CONFIG_PATH)
try:
self.tree.parse(PROJECT_CONFIG_FILE)
except:
root = Element('Project', {'name':os.path.basename(os.getcwd())})
self.tree._setroot(root)
def save(self):
self.tree.write(PROJECT_CONFIG_FILE, xml_declaration=True, method="xml")
def iter(self):
return self.tree.iter('SubProject')
def find(self, name):
for i in self.iter():
if i.get('name') == name:
return i
def inSubProject(self):
cwd = os.getcwd()
for node in self.iter():
name = node.get('name')
print("")
print("On:%s" % name)
print("***************************************")
os.chdir("/".join([cwd, name]))
yield
print("***************************************")
def clone(self):
for module in self.iter():
self.git.clone(module)
def __init_module(self, module):
if not os.path.exists(module):
print("module %s not exists." % module)
return None
cwd = os.getcwd()
os.chdir("/".join([cwd, module]))
if self.git.is_repo():
node = Element('SubProject')
node.set("name", module)
current_branch = self.git.current_branch()
if current_branch != None:
node.set("branch", current_branch)
remote_uri = self.git.current_remote_uri(branch=current_branch)
if remote_uri != None:
node.set("uri", remote_uri)
else:
node = None
else:
print("fatal: Not a git repository")
node = None
os.chdir(cwd)
return node
def __append_ignore_file(self, module):
if os.path.exists(".gitignore"):
ignoreFile = open(".gitignore","r")
for line in ignoreFile:
if module == line.strip():
return
ignoreFile.close()
ignoreFile = open(".gitignore", "a")
ignoreFile.write(module + "\n")
ignoreFile.close()
def __remove_ignore_file(self, modules):
if os.path.exists(".gitignore"):
ignoreFile = open(".gitignore","r")
print modules
data = [line.strip() for line in ignoreFile if not (line.strip() in modules)]
ignoreFile = open(".gitignore", "w")
ignoreFile.write("\n".join(data)+"\n")
ignoreFile.close()
data = None
def append(self, module):
if module == None:
return -1
node = self.find(module)
root = self.tree.getroot()
if node != None:
root.remove(node)
node = self.__init_module(module)
if node == None:
return -1
else:
root.append(node)
self.__append_ignore_file(module)
self.save()
return 0
def remove(self, module=None):
if module != None:
node = self.find(module)
root = self.tree.getroot()
if node != None:
root.remove(node)
self.__remove_ignore_file(module)
self.save()
else:
data = [node.get('name') for node in self.iter()]
self.__remove_ignore_file(data)
def clone(urlStr, directory):
git = Git(urlStr)
git.clone(directory)
def test_tag(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
git.tag(git.latest_commit_id(), "release/1.2.3")
tag_query = lib.call("git describe --abbrev=0 --match release/*")
self.assertEqual(tag_query.stdout.read().strip(), "release/1.2.3")
def test_describe_never_tagged_before(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
latest_tag = git.describe()
self.assertEqual(latest_tag, "0.0.0")
def test_clone(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
self.assertTrue(os.path.exists(os.path.join(test_repo_dir, "README.md")) == 1)
def test_describe_never_tagged_before(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
lib.call_and_exit_if_failed("git tag -a release/0.1.1 -m 'releasing version'")
latest_tag = git.describe()
self.assertEqual(latest_tag, "0.1.1")
def test_clone(self):
git = Git(root_dir_local, test_repo_dir)
git.clone()
self.assertTrue(
os.path.exists(os.path.join(test_repo_dir, "README.md")) == 1)
