mirror of
https://github.com/lucaspalomodevelop/indico-plugins.git
synced 2026-03-13 07:29:39 +00:00
249 lines
10 KiB
Python
249 lines
10 KiB
Python
# This file is part of the Indico plugins.
|
|
# Copyright (C) 2002 - 2024 CERN
|
|
#
|
|
# The Indico plugins are free software; you can redistribute
|
|
# them and/or modify them under the terms of the MIT License;
|
|
# see the LICENSE file for more details.
|
|
|
|
import os
|
|
import sys
|
|
import time
|
|
import traceback
|
|
|
|
import click
|
|
from flask_pluginengine import current_plugin
|
|
from terminaltables import AsciiTable
|
|
|
|
from indico.cli.core import cli_group
|
|
from indico.core.config import config
|
|
from indico.core.db import db
|
|
from indico.util.console import cformat
|
|
|
|
from indico_livesync.models.agents import LiveSyncAgent
|
|
from indico_livesync.models.queue import ChangeType, EntryType, LiveSyncQueueEntry
|
|
from indico_livesync.util import get_excluded_categories, obj_ref
|
|
|
|
|
|
@cli_group(name='livesync')
|
|
def cli():
|
|
"""Manage the LiveSync plugin."""
|
|
|
|
|
|
@cli.command()
|
|
def available_backends():
|
|
"""Lists the currently available backend types."""
|
|
print('The following LiveSync agents are available:')
|
|
for name, backend in current_plugin.backend_classes.items():
|
|
print(cformat(' - %{white!}{}%{reset}: {} ({})').format(name, backend.title, backend.description))
|
|
|
|
|
|
@cli.command()
|
|
def agents():
|
|
"""Lists the currently active agents."""
|
|
print('The following LiveSync agents are active:')
|
|
agent_list = LiveSyncAgent.query.order_by(LiveSyncAgent.backend_name, db.func.lower(LiveSyncAgent.name)).all()
|
|
table_data = [['ID', 'Name', 'Backend', 'Queue', 'Status']]
|
|
for agent in agent_list:
|
|
if agent.backend is None:
|
|
backend_title = cformat('%{red!}invalid backend ({})%{reset}').format(agent.backend_name)
|
|
queue_status = 'n/a'
|
|
else:
|
|
backend_title = agent.backend.title
|
|
backend = agent.create_backend()
|
|
queue_allowed, reason = backend.check_queue_status()
|
|
if queue_allowed:
|
|
queue_status = cformat('%{green!}ready%{reset}')
|
|
else:
|
|
queue_status = cformat('%{yellow!}{}%{reset}').format(reason)
|
|
table_data.append([str(agent.id), agent.name, backend_title,
|
|
str(agent.queue.filter_by(processed=False).count()), queue_status])
|
|
table = AsciiTable(table_data)
|
|
table.justify_columns[3] = 'right'
|
|
print(table.table)
|
|
if not all(a.initial_data_exported for a in agent_list):
|
|
print()
|
|
print('You need to perform the initial data export for some agents.')
|
|
print(cformat('To do so, run '
|
|
'%{yellow!}indico livesync initial-export %{reset}%{yellow}<agent_id>%{reset} for those agents.'))
|
|
|
|
|
|
@cli.command()
|
|
@click.argument('agent_id', type=int)
|
|
@click.option('--retry', '-r', is_flag=True, help='Restart automatically after a failure')
|
|
@click.option('--force', '-f', is_flag=True, help='Perform export even if it has already been done once.')
|
|
@click.option('--verbose', '-v', is_flag=True, help='Be more verbose (what this does is up to the backend)')
|
|
@click.option('--batch', type=int, default=5000, help='The amount of records yielded per export batch.',
|
|
show_default=True, metavar='N')
|
|
def initial_export(agent_id, batch, force, verbose, retry):
|
|
"""Performs the initial data export for an agent."""
|
|
agent = LiveSyncAgent.get(agent_id)
|
|
if agent is None:
|
|
print('No such agent')
|
|
return
|
|
|
|
if agent.backend is None:
|
|
print(cformat('Cannot run agent %{red!}{}%{reset} (backend not found)').format(agent.name))
|
|
return
|
|
|
|
print(cformat('Selected agent: %{white!}{}%{reset} ({})').format(agent.name, agent.backend.title))
|
|
|
|
backend = agent.create_backend()
|
|
if not backend.is_configured():
|
|
print(cformat('Agent %{red!}{}%{reset} is not properly configured').format(agent.name))
|
|
return
|
|
|
|
if agent.initial_data_exported and not force:
|
|
print('The initial export has already been performed for this agent.')
|
|
print(cformat('To re-run it, use %{yellow!}--force%{reset}'))
|
|
return
|
|
|
|
try:
|
|
if not backend.run_initial_export(batch, force, verbose):
|
|
print('The initial export failed; not marking it as done')
|
|
return
|
|
except Exception:
|
|
if not retry:
|
|
raise
|
|
traceback.print_exc()
|
|
print('Restarting in 2 seconds')
|
|
time.sleep(2)
|
|
os.execl(sys.argv[0], *sys.argv) # noqa: S606
|
|
return # exec doesn't return but just in case...
|
|
|
|
agent.initial_data_exported = True
|
|
db.session.commit()
|
|
|
|
|
|
@cli.command()
|
|
@click.argument('agent_id', type=int, required=False)
|
|
@click.option('--force', '-f', is_flag=True, help='Run even if initial export was not done')
|
|
@click.option('--verbose', '-v', is_flag=True, help='Be more verbose (what this does is up to the backend)')
|
|
@click.option('--allow-category', '-c', 'allowed_categories', multiple=True, type=int,
|
|
help="Process changes for the specified category id even if 'Skip category changes' is enabled. "
|
|
"This setting can be used multiple times.")
|
|
def run(agent_id, force, verbose, allowed_categories):
|
|
"""Runs the livesync agent."""
|
|
from indico_livesync.plugin import LiveSyncPlugin
|
|
|
|
if LiveSyncPlugin.settings.get('disable_queue_runs'):
|
|
print(cformat('%{yellow!}Queue runs are disabled%{reset}'))
|
|
if LiveSyncPlugin.settings.get('skip_category_changes'):
|
|
print(cformat('%{yellow!}Category changes are currently being skipped%{reset}'))
|
|
if allowed_categories:
|
|
print(cformat('Whitelisted categories: %{green}{}%{reset}')
|
|
.format(', '.join(map(str, sorted(allowed_categories)))))
|
|
|
|
if agent_id is None:
|
|
agent_list = LiveSyncAgent.query.all()
|
|
else:
|
|
agent = LiveSyncAgent.get(agent_id)
|
|
if agent is None:
|
|
print('No such agent')
|
|
return
|
|
agent_list = [agent]
|
|
|
|
for agent in agent_list:
|
|
if agent.backend is None:
|
|
print(cformat('Skipping agent: %{red!}{}%{reset} (backend not found)').format(agent.name))
|
|
continue
|
|
backend = agent.create_backend()
|
|
queue_allowed, reason = backend.check_queue_status()
|
|
if not queue_allowed and not force:
|
|
print(cformat('Skipping agent: %{red!}{}%{reset} ({})').format(agent.name, reason))
|
|
continue
|
|
print(cformat('Running agent: %{white!}{}%{reset}').format(agent.name))
|
|
try:
|
|
backend.run(verbose, from_cli=True, allowed_categories=allowed_categories)
|
|
db.session.commit()
|
|
except Exception:
|
|
db.session.rollback()
|
|
raise
|
|
|
|
|
|
@cli.command()
|
|
@click.argument('agent_id', type=int)
|
|
def reset(agent_id):
|
|
"""Resets all livesync data for an agent."""
|
|
agent = LiveSyncAgent.get(agent_id)
|
|
if agent is None:
|
|
print('No such agent')
|
|
return
|
|
|
|
if agent.backend is None:
|
|
print(cformat('Cannot run agent %{red!}{}%{reset} (backend not found)').format(agent.name))
|
|
return
|
|
|
|
backend = agent.create_backend()
|
|
reset_allowed, message = backend.check_reset_status()
|
|
|
|
if not reset_allowed:
|
|
print(f'Resetting is not possible: {message}')
|
|
return
|
|
|
|
print(cformat('Selected agent: %{white!}{}%{reset} ({})').format(agent.name, backend.title))
|
|
print(cformat('%{yellow!}!!! %{red!}DANGER %{yellow!}!!!%{reset}'))
|
|
if backend.reset_deletes_indexed_data:
|
|
print(cformat('%{yellow!}This command will delete all indexed data on this backend.%{reset}')
|
|
.format(backend.title))
|
|
else:
|
|
print(cformat('%{yellow!}This command should only be used if the data on this backend '
|
|
'has been deleted.%{reset}')
|
|
.format(backend.title))
|
|
print(cformat('%{yellow!}After resetting you need to perform a new initial export.%{reset}'))
|
|
click.confirm(click.style('Do you really want to perform the reset?', fg='red', bold=True),
|
|
default=False, abort=True)
|
|
if not config.DEBUG:
|
|
click.confirm(click.style('Are you absolutely sure?', fg='red', bold=True), default=False, abort=True)
|
|
for i in range(5):
|
|
print(cformat('\rResetting in %{white!}{}%{reset}s (CTRL+C to abort)').format(5 - i), end='')
|
|
time.sleep(1)
|
|
print()
|
|
|
|
backend.reset()
|
|
db.session.commit()
|
|
print(cformat('Reset complete; run %{green!}indico livesync initial-export {}%{reset} for a new export')
|
|
.format(agent.id))
|
|
|
|
|
|
@cli.command()
|
|
@click.option('--type', '-t',
|
|
type=click.Choice(EntryType.__members__),
|
|
callback=lambda c, p, v: getattr(EntryType, v) if v else None,
|
|
default='event',
|
|
help='The object type (default: event)')
|
|
@click.option('--change', '-c',
|
|
type=click.Choice(ChangeType.__members__),
|
|
callback=lambda c, p, v: getattr(ChangeType, v) if v else None,
|
|
default='protection_changed',
|
|
help='The change type (default: protection_changed)')
|
|
@click.argument('ids', nargs=-1, type=int, metavar='ID...')
|
|
def enqueue(type, change, ids):
|
|
"""Adds the given objects to the LiveSync queues.
|
|
|
|
This is intended to be used if a change was not recorded by LiveSync
|
|
for some reason and you want to manually force an update. Note that
|
|
enqueuing a deletion for something that is not deleted may be
|
|
dangerous and can cause agent runs to fail.
|
|
|
|
By default this util uses the `protection_changed` change type since
|
|
that way it cascades to all child objects when used on anything except
|
|
categories.
|
|
"""
|
|
|
|
model = {
|
|
EntryType.category: db.m.Category,
|
|
EntryType.event: db.m.Event,
|
|
EntryType.contribution: db.m.Contribution,
|
|
EntryType.subcontribution: db.m.SubContribution,
|
|
EntryType.session: db.m.Session,
|
|
EntryType.note: db.m.EventNote,
|
|
EntryType.attachment: db.m.Attachment,
|
|
}[type]
|
|
|
|
objs = model.query.filter(model.id.in_(ids)).all()
|
|
excluded_categories = get_excluded_categories()
|
|
for obj in objs:
|
|
click.echo(f'Enqueuing {obj}')
|
|
LiveSyncQueueEntry.create({change}, obj_ref(obj), excluded_categories=excluded_categories)
|
|
db.session.commit()
|