def _on_rsync_stanza(self, iq):
""" Called when a Rsync stanza is received. This handler creates a
new RsyncTask if permissions are good.
"""
self.logger.info('Received a rsync stanza.')
# Get the useful data.
node = iq['rsync']['node']
sid = iq['rsync']['sid']
rid = iq['rsync']['rid']
files = iq['rsync']['files']
sfrom = iq['from']
project_path = join(self.working_dir, node, sfrom.bare)
# Verify if the user is a subscriber/owner of the node.
is_subscribed = self._verify_subscription(iq, sfrom.bare, node)
if not is_subscribed:
eventbus.fire('rsync-finished-failure', rid=rid)
return
# The future reply iq.
reply = iq.reply()
# Create the new RsyncTask.
from task import RsyncTask
rsync_task = RsyncTask(sid, rid, sfrom, node, project_path, files)
dispatcher.put(node, rsync_task)
# Register the current rsync_task in the pending_rsyncs dict.
self.pending_rsyncs[rid] = rsync_task
# Reply to the IQ
reply['rsync']
reply.send()
def _on_merge_stanza(self, iq):
""" Called when a MergeVerification stanza is received. This handler
creates a new MergeTask if permissions are good.
"""
# Get the useful data.
sfrom = iq['from'].bare
node = iq['merge']['node']
project_path = join(self.working_dir, node, sfrom)
# Verify if the user is a subscriber/owner of the node.
is_subscribed = self._verify_subscription(iq, sfrom, node)
if not is_subscribed:
eventbus.fire("rsync-finished-failure")
return
# Verify if the server-side project is a git repository.
is_git_repo = self._verify_git_repository(iq, node, project_path)
if not is_git_repo:
return
# The future reply iq.
reply = iq.reply()
# Prepare the merge verification with this data.
from task import MergeTask
dispatcher.put(node, MergeTask(node, sfrom))
# Reply to the request.
reply.send()
def _on_failed_auth(self, event):
""" Called when authentication failed.
"""
self.logger.error("Authentication failed.")
eventbus.fire('failed-auth')
self.close()
def _on_git_init_stanza(self, iq):
""" Called when a GitInit stanza is received. This handler creates a
new GitInitTask if permissions are good.
"""
self.logger.info("Received a git init stanza.")
# Get the useful data.
node = iq['git-init']['node']
url = iq['git-init']['url']
sfrom = iq['from'].bare
# Ensure permissions.
is_subscribed = self._verify_subscription(iq, sfrom, node)
if not is_subscribed:
eventbus.fire("rsync-finished-failure")
return
# Create a new GitInitTask
from baboon.baboond.task import GitInitTask
git_init_task = GitInitTask(node, url, sfrom)
# Register the BaboonId of this GitInitTask in the
# self.pending_git_init_tasks dict.
self.pending_git_init_tasks[git_init_task.bid] = iq
# Add the GitInitTask to the list of tasks to execute.
dispatcher.put(node, git_init_task)
def _on_merge_stanza(self, iq):
""" Called when a MergeVerification stanza is received. This handler
creates a new MergeTask if permissions are good.
"""
# Get the useful data.
sfrom = iq['from'].bare
node = iq['merge']['node']
project_path = join(self.working_dir, node, sfrom)
# Verify if the user is a subscriber/owner of the node.
is_subscribed = self._verify_subscription(iq, sfrom, node)
if not is_subscribed:
eventbus.fire("rsync-finished-failure")
return
# Verify if the server-side project is a git repository.
is_git_repo = self._verify_git_repository(iq, node, project_path)
if not is_git_repo:
return
# The future reply iq.
reply = iq.reply()
# Prepare the merge verification with this data.
from task import MergeTask
dispatcher.put(node, MergeTask(node, sfrom))
# Reply to the request.
reply.send()
def _on_failed_auth(self, event):
""" Called when authentication failed.
"""
self.logger.error("Authentication failed.")
eventbus.fire('failed-auth')
self.close()
def _pubsub_event(self, msg):
""" Called when a pubsub event is received.
"""
if msg['type'] in ('normal', 'headline'):
self.logger.debug("Received pubsub item(s): \n%s" %
msg['pubsub_event'])
items = msg['pubsub_event']['items']['substanzas']
for item in items:
notif_msg = ""
if isinstance(item, EventItem):
self.logger.info(item['payload'].get('status'))
notif_msg += item['payload'].get('status')
for err_f in item['payload']:
if err_f.text:
err = "> %s" % err_f.text
self.logger.warning(err)
notif_msg = "%s\n%s" % (notif_msg, err)
if item['payload'].get('type') == 'error':
eventbus.fire('conflict-result', notif_msg)
else:
self.logger.debug("Received pubsub event: \n%s" %
msg['pubsub_event'])
def _on_rsync_stanza(self, iq):
""" Called when a Rsync stanza is received. This handler creates a
new RsyncTask if permissions are good.
"""
self.logger.info('Received a rsync stanza.')
# Get the useful data.
node = iq['rsync']['node']
sid = iq['rsync']['sid']
rid = iq['rsync']['rid']
files = iq['rsync']['files']
sfrom = iq['from']
project_path = join(self.working_dir, node, sfrom.bare)
# Verify if the user is a subscriber/owner of the node.
is_subscribed = self._verify_subscription(iq, sfrom.bare, node)
if not is_subscribed:
eventbus.fire('rsync-finished-failure', rid=rid)
return
# The future reply iq.
reply = iq.reply()
# Create the new RsyncTask.
from task import RsyncTask
rsync_task = RsyncTask(sid, rid, sfrom, node, project_path, files)
dispatcher.put(node, rsync_task)
# Register the current rsync_task in the pending_rsyncs dict.
self.pending_rsyncs[rid] = rsync_task
# Reply to the IQ
reply['rsync']
reply.send()
def _on_git_init_stanza(self, iq):
""" Called when a GitInit stanza is received. This handler creates a
new GitInitTask if permissions are good.
"""
self.logger.info("Received a git init stanza.")
# Get the useful data.
node = iq['git-init']['node']
url = iq['git-init']['url']
sfrom = iq['from'].bare
# Ensure permissions.
is_subscribed = self._verify_subscription(iq, sfrom, node)
if not is_subscribed:
eventbus.fire("rsync-finished-failure")
return
# Create a new GitInitTask
from baboon.baboond.task import GitInitTask
git_init_task = GitInitTask(node, url, sfrom)
# Register the BaboonId of this GitInitTask in the
# self.pending_git_init_tasks dict.
self.pending_git_init_tasks[git_init_task.bid] = iq
# Add the GitInitTask to the list of tasks to execute.
dispatcher.put(node, git_init_task)
def _on_new_rsync(self, project, files, **kwargs):
""" Called when a new rsync needs to be started.
"""
self.connected.wait()
self.rsync(project, files=files)
eventbus.fire('rsync-finished-success', project, files)
def _on_new_rsync(self, project, files, **kwargs):
""" Called when a new rsync needs to be started.
"""
self.connected.wait()
self.rsync(project, files=files)
eventbus.fire('rsync-finished-success', project, files)
def run(self):
self.logger.debug('A new git init task has been started.')
# If the project directory already exists, delete it.
if os.path.exists(self.user_cwd):
shutil.rmtree(self.user_cwd)
create_missing_dirs(self.project_cwd, isfile=False)
ret_code, output, _ = exec_cmd('git clone %s %s' % (
self.url, self.jid), self.project_cwd)
if not ret_code:
self.logger.debug('Git init task finished.')
eventbus.fire('git-init-success', self.bid)
else:
eventbus.fire('git-init-failure', self.bid,
"Cannot initialize the git repository.")
def run(self):
self.logger.debug('A new git init task has been started.')
# If the project directory already exists, delete it.
if os.path.exists(self.user_cwd):
shutil.rmtree(self.user_cwd)
create_missing_dirs(self.project_cwd, isfile=False)
ret_code, output, _ = exec_cmd(
'git clone %s %s' % (self.url, self.jid), self.project_cwd)
if not ret_code:
self.logger.debug('Git init task finished.')
eventbus.fire('git-init-success', self.bid)
else:
eventbus.fire('git-init-failure', self.bid,
"Cannot initialize the git repository.")
def run(self):
""" Runs the thread.
"""
while not self.stop:
# Sleeps during sleeptime secs.
sleep(self.sleeptime)
with lock:
for project, files in pending.iteritems():
try:
eventbus.fire('new-rsync', project=project,
files=files)
except BaboonException as e:
self.logger.error(e)
# Clears the pending dict.
pending.clear()
def run(self):
self.logger.debug('RsyncTask %s started' % self.sid)
# Lock the repository with a .baboon.lock file.
lock_file = os.path.join(self.project_path, '.baboon.lock')
create_missing_dirs(lock_file)
open(lock_file, 'w').close()
for f in self.files:
# Verify if the file can be written in the self.project_path.
path_valid = self._verify_paths(f)
if not path_valid:
self.logger.error("The file path cannot be written in %s." %
self.project)
eventbus.fire('rsync-finished-failure', rid=self.rid)
return
if f.event_type == FileEvent.CREATE:
self.logger.debug('[%s] - Need to create %s.' %
(self.project_path, f.src_path))
self._create_file(f.src_path)
elif f.event_type == FileEvent.MODIF:
self.logger.debug('[%s] - Need to sync %s.' %
(self.project_path, f.src_path))
new_hash = self._get_hash(f.src_path)
self._send_hash(new_hash)
elif f.event_type == FileEvent.DELETE:
self.logger.debug('[%s] - Need to delete %s.' %
(self.project_path, f.src_path))
self._delete_file(f.src_path)
elif f.event_type == FileEvent.MOVE:
self.logger.debug('[%s] - Need to move %s to %s.' %
(self.project_path, f.src_path, f.dest_path))
self._move_file(f.src_path, f.dest_path)
# Remove the .baboon.lock file.
os.remove(lock_file)
# Fire the rsync-finished-success event.
eventbus.fire('rsync-finished-success', rid=self.rid)
self.logger.debug('Rsync task %s finished', self.sid)
def run(self):
self.logger.debug('RsyncTask %s started' % self.sid)
# Lock the repository with a .baboon.lock file.
lock_file = os.path.join(self.project_path, '.baboon.lock')
create_missing_dirs(lock_file)
open(lock_file, 'w').close()
for f in self.files:
# Verify if the file can be written in the self.project_path.
path_valid = self._verify_paths(f)
if not path_valid:
self.logger.error("The file path cannot be written in %s." %
self.project)
eventbus.fire('rsync-finished-failure', rid=self.rid)
return
if f.event_type == FileEvent.CREATE:
self.logger.debug('[%s] - Need to create %s.' %
(self.project_path, f.src_path))
self._create_file(f.src_path)
elif f.event_type == FileEvent.MODIF:
self.logger.debug('[%s] - Need to sync %s.' %
(self.project_path, f.src_path))
new_hash = self._get_hash(f.src_path)
self._send_hash(new_hash)
elif f.event_type == FileEvent.DELETE:
self.logger.debug('[%s] - Need to delete %s.' %
(self.project_path, f.src_path))
self._delete_file(f.src_path)
elif f.event_type == FileEvent.MOVE:
self.logger.debug('[%s] - Need to move %s to %s.' %
(self.project_path, f.src_path, f.dest_path))
self._move_file(f.src_path, f.dest_path)
# Remove the .baboon.lock file.
os.remove(lock_file)
# Fire the rsync-finished-success event.
eventbus.fire('rsync-finished-success', rid=self.rid)
self.logger.debug('Rsync task %s finished', self.sid)
def run(self):
""" Runs the thread.
"""
while not self.stop:
# Sleeps during sleeptime secs.
sleep(self.sleeptime)
with lock:
for project, files in pending.iteritems():
try:
eventbus.fire('new-rsync',
project=project,
files=files)
except BaboonException as e:
self.logger.error(e)
# Clears the pending dict.
pending.clear()
