def gitPush(self, path, comment=None):
# Announce changes to git
cmd = Git(path)
changed = False
for line in cmd.status("--porcelain").splitlines():
changed = True
line = line.lstrip()
self.log.info("staging changes for %s" % line.split(" ", 1)[1:])
mode, file_path = line.split(" ", 1)
file_path = os.path.join(*file_path.split("/")[0:])
# Remove data?
if mode == "D":
cmd.rm("-r", file_path)
# Add data...
else:
cmd.add(file_path)
# No need to deal...
if not changed:
return False
# Commit changes
if not comment:
comment = "Change made with no comment"
self.log.info("committing changes for module %s" % path)
cmd.commit("-m", comment)
cmd.push("origin")
return True
def save(self, *args, **kwargs):
message = kwargs.pop('message', self._next_message() or 'update')
super(Fork, self).save(*args, **kwargs)
with open(os.path.join(self.git_path, "BODY"), 'w') as f:
f.write(self.body)
git = Git(self.git_path)
git.add('BODY')
try:
git.commit(message=message)
except GitCommandError, e:
if e.status != 1:
raise
def commit_and_push(git: Git, message: str):
"""Stage, commit and push all changes.
Args:
git: (git.cmd.Git) Manages communication with the Git binary.
message: (str) Commit message body.
"""
git.add('-A')
try:
git.commit('-m', message)
except GitCommandError:
logger.warning('Nothing to commit, working tree clean')
git.push()
logger.info(message)
def init_releaserc(debug, info):
path = getcwd()
git = Git(path)
another_env = 'y'
n_th = 'first'
branches = []
secrets = {}
commands = {
"test": "/usr/bin/true"
}
# get branch names and passwords
info('\nLet\'s setup your roll process.')
info('-------------------------------')
while another_env.lower() == 'y' or another_env.lower() == '':
env_name = raw_input('What\'s the name of the ' + n_th + ' environment? ')
branches.append(env_name)
password_required = raw_input('Should a password be required to roll here? (y/N) ')
password = None
if password_required.lower() == 'y':
password = sha.new(getpass()).hexdigest()
secrets[env_name] = password
another_env = raw_input('Is there another environment? (Y/n) ')
n_th = 'next'
info('')
info('Your roll process is:\nmaster -> ' + ' -> '.join(branches))
info('')
info('')
fd = open('.releaserc', 'w')
json.dump({
"branches": branches,
"commands": commands,
"secrets": secrets
}, fd, indent=4, separators=(',', ': '))
debug('adding .releaserc...')
debug(git.add('.releaserc'))
def welcome_package(debug, info):
path = getcwd()
git = Git(path)
fd = open('welcome.txt', 'w')
fd.write('''
Welcome to {tool_name}
=======================
This tool is a helper to be used along side git.
$ {tool_command} init # you just ran this!
$ {tool_command} update
$ {tool_command} roll to dev
$ {tool_command} roll qa to prod
'''.format(tool_name=tool_name, tool_command=tool_command))
debug('adding welcome.txt...')
debug(git.add('welcome.txt'))
info('Welcome to {tool_name}'.format(tool_name=tool_name))
def website_gitrepo(self):
'''Create a new GitHub repository and populate it with content from
a newly generated jekyll website export created via :meth:`website`.
:return: on success, returns a tuple of public repository url and
github pages url for the newly created repo and site
'''
# NOTE: github pages sites now default to https
github_pages_url = 'https://%s.github.io/%s/' % \
(self.github_username, self.github_repo)
# before even starting to generate the jekyll site,
# check if requested repo name already exists; if so, bail out with an error
logger.debug('Checking github repo %s for %s', self.github_repo,
self.github_username)
if self.gitrepo_exists():
raise GithubExportException('GitHub repo %s already exists.' \
% self.github_repo)
export_dir = self.generate_website()
# jekyll dir is *inside* the export directory;
# for the jekyll site to display correctly, we need to commit what
# is in the directory, not the directory itself
jekyll_dir = self.edition_dir(export_dir)
# modify the jekyll config for relative url on github.io
config_file_path = os.path.join(jekyll_dir, '_config.yml')
with open(config_file_path, 'r') as configfile:
config_data = yaml.load(configfile)
# split out github pages url into the site url and path
parsed_gh_url = urlparse(github_pages_url)
config_data['url'] = '%s://%s' % (parsed_gh_url.scheme,
parsed_gh_url.netloc)
config_data['baseurl'] = parsed_gh_url.path.rstrip('/')
with open(config_file_path, 'w') as configfile:
yaml.safe_dump(config_data, configfile, default_flow_style=False)
# using safe_dump to generate only standard yaml output
# NOTE: pyyaml requires default_flow_style=false to output
# nested collections in block format
logger.debug('Creating github repo %s for %s', self.github_repo,
self.github_username)
if self.update_callback is not None:
self.update_callback('Creating GitHub repo %s' % self.github_repo)
self.github.create_repo(
self.github_repo,
homepage=github_pages_url,
description='An annotated digital edition created with Readux')
# get auth repo url to use to push data
repo_url = self.github_auth_repo(repo_name=self.github_repo)
# add the jekyll site to github; based on these instructions:
# https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
# initialize export dir as a git repo, and commit the contents
# NOTE: to debug git commands, print the git return to see git output
gitcmd = Git(jekyll_dir)
# initialize jekyll site as a git repo
gitcmd.init()
# add and commit all contents
gitcmd.add(['.'])
gitcmd.commit([
'-m',
'Import Jekyll site generated by Readux %s' % __version__,
'--author="%s <%s>"' % (self.user.fullname(), self.user.email)
])
# push local master to the gh-pages branch of the newly created repo,
# using the user's oauth token credentials
self.log_status('Pushing content to GitHub')
gitcmd.push([repo_url, 'master:gh-pages'])
# clean up temporary files after push to github
shutil.rmtree(export_dir)
# generate public repo url for display to user
public_repo_url = 'https://github.com/%s/%s' % (self.github_username,
self.github_repo)
return (public_repo_url, github_pages_url)
def website_gitrepo(self, user, repo_name):
'''Create a new GitHub repository and populate it with content from
a newly generated jekyll website export created via :meth:`website`.
:param user: user
:param repo_name: name of the GitHub repository to be created;
raises :class:`GithubExportException` if the repository already
exists
:param vol: :class:`~readux.books.models.Volume` to be exported
(1.0 or 1.1)
:param tei: annotated TEI facsimile (e.g.,
:class:`~readux.books.tei.AnnotatedFacsimile`)
:param page_one: page where numbering should start from 1 in the export
:return: on success, returns a tuple of public repository url and
github pages url for the newly created repo and site
'''
# connect to github as the user in order to create the repository
self.use_github(user)
# NOTE: github pages sites now default to https
github_pages_url = 'https://%s.github.io/%s/' % \
(self.github_username, repo_name)
# before even starting to generate the jekyll site,
# check if requested repo name already exists; if so, bail out with an error
current_repos = self.github.list_repos(self.github_username)
current_repo_names = [repo['name'] for repo in current_repos]
if repo_name in current_repo_names:
raise GithubExportException('GitHub repo %s already exists.' \
% repo_name)
export_dir = self.generate_website()
# jekyll dir is *inside* the export directory;
# for the jekyll site to display correctly, we need to commit what
# is in the directory, not the directory itself
jekyll_dir = self.get_jekyll_site_dir(export_dir)
# modify the jekyll config for relative url on github.io
config_file_path = os.path.join(jekyll_dir, '_config.yml')
with open(config_file_path, 'r') as configfile:
config_data = yaml.load(configfile)
# split out github pages url into the site url and path
parsed_gh_url = urlparse(github_pages_url)
config_data['url'] = '%s://%s' % (parsed_gh_url.scheme,
parsed_gh_url.netloc)
config_data['baseurl'] = parsed_gh_url.path.rstrip('/')
with open(config_file_path, 'w') as configfile:
yaml.safe_dump(config_data, configfile,
default_flow_style=False)
# using safe_dump to generate only standard yaml output
# NOTE: pyyaml requires default_flow_style=false to output
# nested collections in block format
logger.debug('Creating github repo %s for %s', repo_name,
self.github_username)
if self.update_callback is not None:
self.update_callback('Creating GitHub repo %s' % repo_name)
self.github.create_repo(
repo_name, homepage=github_pages_url,
description='An annotated digital edition created with Readux')
# get auth repo url to use to push data
repo_url = self.github_auth_repo(repo_name=repo_name)
# add the jekyll site to github; based on these instructions:
# https://help.github.com/articles/adding-an-existing-project-to-github-using-the-command-line/
# initialize export dir as a git repo, and commit the contents
# NOTE: to debug git commands, print the git return to see git output
gitcmd = Git(jekyll_dir)
# initialize jekyll site as a git repo
gitcmd.init()
# add and commit all contents
gitcmd.add(['.'])
gitcmd.commit(
['-m', 'Import Jekyll site generated by Readux %s' % __version__,
'--author="%s <%s>"' % (settings.GIT_AUTHOR_NAME,
settings.GIT_AUTHOR_EMAIL)])
# push local master to the gh-pages branch of the newly created repo,
# using the user's oauth token credentials
self.log_status('Pushing content to GitHub')
gitcmd.push([repo_url, 'master:gh-pages'])
# clean up temporary files after push to github
shutil.rmtree(export_dir)
# generate public repo url for display to user
public_repo_url = 'https://github.com/%s/%s' % (self.github_username,
repo_name)
return (public_repo_url, github_pages_url)
def __init__(self, manager):
super(PuppetInstallMethod, self).__init__(manager)
self.log = logging.getLogger(__name__)
# Use effective agent user's home directory
self.__path = pwd.getpwuid(os.getuid()).pw_dir
# Load install items
for entry in pkg_resources.iter_entry_points("puppet.items"):
module = entry.load()
self.log.info("repository handler %s included" % module.__name__)
self._supportedItems.update({
module.__name__ : {
'name': module._name,
'description': module._description,
'container': module._container,
'options': module._options,
'module': module,
},
})
# Get a backend instance for that path
self.__repo_path = os.path.join(self.__path, "repo")
self.__work_path = os.path.join(self.__path, "work")
# Purge path if wanted
db_purge = self.env.config.get('repository.db_purge',)
if db_purge == "True":
if os.path.exists(self.__repo_path):
shutil.rmtree(self.__repo_path)
if os.path.exists(self.__work_path):
shutil.rmtree(self.__work_path)
# Create path if it doesn't exist
if not os.path.exists(self.__path):
os.makedirs(self.__path, 0750)
if not os.path.exists(self.__repo_path):
os.makedirs(self.__repo_path, 0750)
if not os.path.exists(self.__work_path):
os.makedirs(self.__work_path, 0750)
# Initialize git repository if not present
if not os.path.exists(os.path.join(self.__repo_path, "config")):
repo = Repo.create(self.__repo_path)
assert repo.bare == True
os.chmod(self.__repo_path, 0750)
# Create master branch
tmp_path = os.path.join(self.__work_path, "master")
cmd = Git(self.__work_path)
cmd.clone(self.__repo_path, "master")
with open(os.path.join(tmp_path, "README"), "w") as f:
f.write("This is an automatically managed GOsa puppet repository. Please do not modify.")
logdir = self.env.config.get("puppet.report-dir",
"/var/log/puppet")
with open(os.path.join(tmp_path, "puppet.conf"), "w") as f:
f.write("""[main]
logdir=%s
vardir=/var/lib/puppet
ssldir=/var/lib/puppet/ssl
rundir=/var/run/puppet
factpath=$vardir/lib/facter
templatedir=$confdir/templates
report=true
reports=store_gosa
reportdir=$logdir
""" % logdir)
# Add manifests and write initial size.pp
os.mkdir(os.path.join(tmp_path, "manifests"))
with open(os.path.join(tmp_path, "manifests", "site.pp"), "w") as f:
f.write('\nimport "nodes.pp"\n')
# Add manifests and write initial size.pp
with open(os.path.join(tmp_path, "manifests", "nodes.pp"), "w") as f:
f.write('# Automatically managed by GOsa\n')
cmd = Git(tmp_path)
cmd.add("README")
cmd.add("puppet.conf")
cmd.add("manifests")
cmd.commit(m="Initially created puppet master branch")
cmd.push("origin", "master")
shutil.rmtree(tmp_path)
# Create SSH directory?
self.ssh_path = os.path.join(self.__path, '.ssh')
if not os.path.exists(self.ssh_path):
os.makedirs(self.ssh_path)
host = self.env.id
user = pwd.getpwuid(os.getuid()).pw_name
self.gen_ssh_key(os.path.join(self.ssh_path, 'id_dsa'),
"%s@%s" % (user, host))
def createRelease(self, name, parent=None):
super(PuppetInstallMethod, self).createRelease(name, parent)
with puppet_lock:
# Move to concrete directory name
orig_name = name
name = name.replace("/", "@")
# Clone repository
cmd = Git(self.__work_path)
if parent:
if isinstance(parent, StringTypes):
parent = parent.replace("/", "@")
else:
parent = parent.name.replace("/", "@")
self.log.debug("cloning new git branch '%s' from '%s'"
% (name, parent))
cmd.clone(self.__repo_path, name, b=parent)
else:
self.log.debug("creating new git branch '%s'" % name)
cmd.clone(self.__repo_path, name)
# Switch branch, add information
cmd = Git(os.path.join(self.__work_path, name))
host = self.env.id
cmd.config("--global", "user.name", "GOsa management agent on %s" % host)
self.log.debug("switching to newly created branch")
cmd.checkout(b=name)
# Remove refs if there's no parent
current_dir = os.path.join(self.__work_path, name)
if not parent:
self.log.debug("no parent set - removing refs")
cmd.symbolic_ref("HEAD", "refs/heads/newbranch")
os.remove(os.path.join(current_dir, ".git", "index"))
files = os.listdir(current_dir)
# Remove all but .git
for f in files:
if f== ".git":
continue
if os.path.isdir(f):
shutil.rmtree(os.path.join(current_dir, f))
else:
os.unlink(os.path.join(current_dir, f))
# Create release info file
self.log.debug("writing release info file in %s" % current_dir)
with open(os.path.join(current_dir, "release.info"), "w") as f:
now = datetime.now()
f.write("Release: %s\n" % orig_name)
f.write("Date: %s\n" % now.strftime("%Y-%m-%d %H:%M:%S"))
self.log.debug("comitting new release")
cmd.add("release.info")
cmd.commit(m="Created release information")
# Push to origin
self.log.debug("pushing change to central repository")
cmd.push("origin", name)
return True
