def configure_queue(event):
    """ Configure zc.async queue for land files async jobs
    """
    queue = event.object
    size = get_maximum_threads(queue)
    set_quota(queue, NAME, size=size)

    logger.info(
        "quota %s with size %r configured in queue %r.",
        NAME,
        size,
        queue.name,
    )
Beispiel #2
0
from plone.app.async.subscribers import set_quota
logger = logging.getLogger('eea.pdf')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1

def configureQueue(event):
    """ Configure zc.async queue for PDF export jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get('EEAPDF_ASYNC_THREADS',
                                  getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'pdf', size=size)
    logger.info(
        "quota 'pdf' with size %r configured in queue %r.", size, queue.name)
Beispiel #3
0
logger = logging.getLogger('eea.sparql')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get(
            'EEASPARQL_ASYNC_THREADS', getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'sparql', size=size)
    logger.info("quota 'sparql' with size %r configured in queue %r.",
                size, queue.name)
logger = logging.getLogger('Products.EEAContentTypes')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for EEAContentTypes jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get(
            'EEACONTENTTYPES_ASYNC_THREADS', getMaximumThreads(queue)))
    except Exception, err:
        logger.warn(err)
        size = 1

    set_quota(queue, 'ctypes', size=size)
    logger.info("quota 'ctypes' with size %r configured in queue %r.",
                size, queue.name)
Beispiel #5
0

def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(
            os.environ.get('EEASPARQL_ASYNC_THREADS',
                           getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'sparql', size=size)
    logger.info("quota 'sparql' with size %r configured in queue %r.", size,
                queue.name)
Beispiel #6
0
logger = logging.getLogger('eea.rdfmarshaller')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(
            os.environ.get('EEARDF_ASYNC_THREADS', getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'rdf', size=size)
    logger.info("quota 'rdf' with size %r configured in queue %r.", size,
                queue.name)

def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for EEAContentTypes jobs
    """
    queue = event.object

    try:
        size = int(
            os.environ.get('EEACONTENTTYPES_ASYNC_THREADS',
                           getMaximumThreads(queue)))
    except Exception, err:
        logger.warn(err)
        size = 1

    set_quota(queue, 'ctypes', size=size)
    logger.info("quota 'ctypes' with size %r configured in queue %r.", size,
                queue.name)
Beispiel #8
0
logger = logging.getLogger('eea.similarity')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for similarity export jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get(
            'EEASIMILARITY_ASYNC_THREADS', getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'similarity', size=size)
    logger.info("quota 'similarity' with size %r configured in queue %r.",
                size, queue.name)
Beispiel #9
0

def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(
            os.environ.get('EEADATASERVICE_ASYNC_THREADS',
                           getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'data', size=size)
    logger.info("quota 'data' with size %r configured in queue %r.", size,
                queue.name)
Beispiel #10
0
logger = logging.getLogger('eea.relations')


def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get(
            'EEARELATIONS_ASYNC_THREADS', getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'relations', size=size)
    logger.info("quota 'relations' with size %r configured in queue %r.",
                size, queue.name)
Beispiel #11
0
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for MOVE jobs
    """
    queue = event.object

    try:
        size = int(os.environ.get('EEASYNCMOVE_ASYNC_THREADS',
                                  getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'asyncmove', size=size)
    logger.info(
        "quota 'asyncmove' with size %r configured in queue %r.",
        size, queue.name)


def saveJobProgress(event):
    """ Save job progress
    """
    portal = getToolByName(event.object, 'portal_url').getPortalObject()
    portal_anno = IAnnotations(portal)
    annotation = portal_anno.get('async_move_jobs')
    annotation_job = annotation.setdefault(event.job_id, {})

    if event.operation == 'initialize':
        annotation_job['sub_progress'] = {}
Beispiel #12
0

def getMaximumThreads(queue):
    """ Get the maximum threads per queue
    """
    size = 0
    for da in queue.dispatchers.values():
        if not da.activated:
            continue
        for _agent in da.values():
            size += 3
    return size or 1


def configureQueue(event):
    """ Configure zc.async queue for rdf async jobs
    """
    queue = event.object

    try:
        size = int(
            os.environ.get('EEARELATIONS_ASYNC_THREADS',
                           getMaximumThreads(queue)))
    except Exception, err:
        logger.exception(err)
        size = 1

    set_quota(queue, 'relations', size=size)
    logger.info("quota 'relations' with size %r configured in queue %r.", size,
                queue.name)