Esempio n. 1
0
def compute_node_utilization_update(context, host, free_ram_mb_delta=0,
                          free_disk_gb_delta=0, work_delta=0, vm_delta=0):
    """Update a specific ComputeNode entry by a series of deltas.
    Do this as a single atomic action and lock the row for the
    duration of the operation. Requires that ComputeNode record exist."""
    session = get_session()
    compute_node = None
    with session.begin(subtransactions=True):
        compute_node = session.query(models.ComputeNode).\
                              options(joinedload('service')).\
                              filter(models.Service.host == host).\
                              filter_by(deleted=False).\
                              with_lockmode('update').\
                              first()
        if compute_node is None:
            raise exception.NotFound(_("No ComputeNode for %(host)s") %
                                     locals())

        # This table thingy is how we get atomic UPDATE x = x + 1
        # semantics.
        table = models.ComputeNode.__table__
        if free_ram_mb_delta != 0:
            compute_node.free_ram_mb = table.c.free_ram_mb + free_ram_mb_delta
        if free_disk_gb_delta != 0:
            compute_node.free_disk_gb = (table.c.free_disk_gb +
                                         free_disk_gb_delta)
        if work_delta != 0:
            compute_node.current_workload = (table.c.current_workload +
                                             work_delta)
        if vm_delta != 0:
            compute_node.running_vms = table.c.running_vms + vm_delta
    return compute_node
Esempio n. 2
0
def compute_node_utilization_set(context, host, free_ram_mb=None,
                                 free_disk_gb=None, work=None, vms=None):
    """Like compute_node_utilization_update() modify a specific host
    entry. But this function will set the metrics absolutely
    (vs. a delta update).
    """
    session = get_session()
    compute_node = None
    with session.begin(subtransactions=True):
        compute_node = session.query(models.ComputeNode).\
                              options(joinedload('service')).\
                              filter(models.Service.host == host).\
                              filter_by(deleted=False).\
                              with_lockmode('update').\
                              first()
        if compute_node is None:
            raise exception.NotFound(_("No ComputeNode for %(host)s") %
                                     locals())

        if free_ram_mb != None:
            compute_node.free_ram_mb = free_ram_mb
        if free_disk_gb != None:
            compute_node.free_disk_gb = free_disk_gb
        if work != None:
            compute_node.current_workload = work
        if vms != None:
            compute_node.running_vms = vms

    return compute_node
Esempio n. 3
0
def model_query(context, *args, **kwargs):
    """Query helper that accounts for context's `read_deleted` field.

    :param context: context to query under
    :param session: if present, the session to use
    :param read_deleted: if present, overrides context's read_deleted field.
    :param project_only: if present and context is user-type, then restrict
            query to match the context's project_id.
    """
    session = kwargs.get('session') or get_session()
    read_deleted = kwargs.get('read_deleted') or context.read_deleted
    project_only = kwargs.get('project_only')

    query = session.query(*args)

    if read_deleted == 'no':
        query = query.filter_by(deleted=False)
    elif read_deleted == 'yes':
        pass  # omit the filter to include deleted and active
    elif read_deleted == 'only':
        query = query.filter_by(deleted=True)
    else:
        raise Exception(
            _("Unrecognized read_deleted value '%s'") % read_deleted)

    if project_only and is_user_context(context):
        query = query.filter_by(project_id=context.project_id)

    return query
Esempio n. 4
0
def monitor_service_create(context, values, session=None):
    if not session:
        session = get_session()

    with session.begin(subtransactions=True):
        monitor_service_ref = models.MonitorService()
        session.add(monitor_service_ref)
        monitor_service_ref.update(values)

    return monitor_service_ref
Esempio n. 5
0
def compute_node_get_by_host(context, host):
    """Get all capacity entries for the given host."""
    session = get_session()
    with session.begin():
        service = session.query(models.Service).\
                            filter_by(host=host, binary="monitor-bmc").first()
        node = session.query(models.ComputeNode).\
                             options(joinedload('service')).\
                             filter_by(deleted=False,service_id=service.id)
        return node.first()
Esempio n. 6
0
 def save(self, session=None):
     """Save this object."""
     if not session:
         session = get_session()
     session.add(self)
     try:
         session.flush()
     except IntegrityError, e:
         if str(e).endswith('is not unique'):
             raise exception.Duplicate(str(e))
         else:
             raise
Esempio n. 7
0
def compute_node_create(context, values, session=None):
    """Creates a new ComputeNode and populates the capacity fields
    with the most recent data."""
    if not session:
        session = get_session()

    _adjust_compute_node_values_for_utilization(context, values, session)
    with session.begin(subtransactions=True):
        compute_node_ref = models.ComputeNode()
        session.add(compute_node_ref)
        compute_node_ref.update(values)
    return compute_node_ref
Esempio n. 8
0
def compute_node_update(context, compute_id, values, auto_adjust):
    """Creates a new ComputeNode and populates the capacity fields
    with the most recent data."""
    session = get_session()
    if auto_adjust:
        _adjust_compute_node_values_for_utilization(context, values, session)
    with session.begin(subtransactions=True):
        values['updated_at'] = timeutils.utcnow()
        convert_datetimes(values, 'created_at', 'deleted_at', 'updated_at')
        compute_ref = compute_node_get(context, compute_id, session=session)
        for (key, value) in values.iteritems():
            compute_ref[key] = value
        compute_ref.save(session=session)
Esempio n. 9
0
def service_get_all_servicemanage_sorted(context):
    session = get_session()
    with session.begin():
        topic = FLAGS.servicemanage_topic
        label = 'servicemanage_gigabytes'
        subq = model_query(context, models.ServiceManage.host,
                           func.sum(models.ServiceManage.size).label(label),
                           session=session, read_deleted="no").\
            group_by(models.ServiceManage.host).\
            subquery()
        return _service_get_all_topic_subquery(context,
                                               session,
                                               topic,
                                               subq,
                                               label)
Esempio n. 10
0
def monitor_service_update(context, monitor_service_id, values):
    session = get_session()
    monitor_service_ref = None
    with session.begin(subtransactions=True):
        values['updated_at'] = timeutils.utcnow()
        convert_datetimes(values, 'created_at', 'deleted_at', 'updated_at')
        monitor_service_ref = monitor_service_get(
                                   context,
                                   monitor_service_id,
                                   session=session)

        if monitor_service_ref is None:
            msg = "No Service Monitored with %s" % monitor_service_id
            raise exception.NotFound(msg)

        for (key, value) in values.iteritems():
            monitor_service_ref[key] = value
        monitor_service_ref.save(session=session)

    return monitor_service_ref
Esempio n. 11
0
def monitor_service_delete(context, monitor_service_id):
    session = get_session()

    with session.begin(subtransactions=True):
        monitor_service_ref = monitor_service_get(context,
                                                  monitor_service_id,
                                                  session=session)

        if monitor_service_ref is None:
            msg = "No Service Monitored with %s" % monitor_service_id
            raise exception.NotFound(msg)

        monitor_service_ref['deleted_at'] = timeutils.utcnow()
        monitor_service_ref['updated_at'] = monitor_service_ref['deleted_at']
        monitor_service_ref['deleted'] = True
        convert_datetimes(monitor_service_ref,
                          'created_at',
                          'deleted_at',
                          'updated_at')

        monitor_service_ref.save(session=session)
Esempio n. 12
0
def service_update(context, service_id, values):
    session = get_session()
    with session.begin():
        service_ref = service_get(context, service_id, session=session)
        service_ref.update(values)
        service_ref.save(session=session)
Esempio n. 13
0
def service_destroy(context, service_id):
    session = get_session()
    with session.begin():
        service_ref = service_get(context, service_id, session=session)
        service_ref.delete(session=session)