def test_six_pt_five(self): x = column("x") self.assert_compile(select([x]).where(or_(x == 7, true())), "SELECT x WHERE true") self.assert_compile(select([x]).where(or_(x == 7, true())), "SELECT x WHERE 1 = 1", dialect=default.DefaultDialect(supports_native_boolean=False))
def test_eleven(self): c = column('x', Boolean) self.assert_compile( c.is_(true()), "x IS true", dialect=self._dialect(True) )
def query_with_hooks(context, model): query = context.session.query(model) # define basic filter condition for model query query_filter = None if db_utils.model_query_scope_is_project(context, model): if hasattr(model, 'rbac_entries'): query = query.outerjoin(model.rbac_entries) rbac_model = model.rbac_entries.property.mapper.class_ query_filter = ( (model.tenant_id == context.tenant_id) | ((rbac_model.action == 'access_as_shared') & ((rbac_model.target_tenant == context.tenant_id) | (rbac_model.target_tenant == '*')))) elif hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for hook in get_hooks(model): query_hook = helpers.resolve_ref(hook.get('query')) if query_hook: query = query_hook(context, model, query) filter_hook = helpers.resolve_ref(hook.get('filter')) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
def get_catalog(self, user_id, tenant_id, metadata=None): substitutions = dict(six.iteritems(CONF)) substitutions.update({'tenant_id': tenant_id, 'user_id': user_id}) session = sql.get_session() endpoints = (session.query(Endpoint). options(sql.joinedload(Endpoint.service)). filter(Endpoint.enabled == true()).all()) catalog = {} for endpoint in endpoints: if not endpoint.service['enabled']: continue try: url = core.format_url(endpoint['url'], substitutions) except exception.MalformedEndpoint: continue # this failure is already logged in format_url() region = endpoint['region_id'] service_type = endpoint.service['type'] default_service = { 'id': endpoint['id'], 'name': endpoint.service.extra.get('name', ''), 'publicURL': '' } catalog.setdefault(region, {}) catalog[region].setdefault(service_type, default_service) interface_url = '%sURL' % endpoint['interface'] catalog[region][service_type][interface_url] = url return catalog
def get_v3_catalog(self, user_id, tenant_id, metadata=None): d = dict(six.iteritems(CONF)) d.update({'tenant_id': tenant_id, 'user_id': user_id}) session = sql.get_session() services = (session.query(Service).filter(Service.enabled == true()). options(sql.joinedload(Service.endpoints)). all()) def make_v3_endpoints(endpoints): for endpoint in (ep.to_dict() for ep in endpoints if ep.enabled): del endpoint['service_id'] del endpoint['legacy_endpoint_id'] del endpoint['enabled'] endpoint['region'] = endpoint['region_id'] try: endpoint['url'] = core.format_url(endpoint['url'], d) except exception.MalformedEndpoint: continue # this failure is already logged in format_url() yield endpoint def make_v3_service(svc): eps = list(make_v3_endpoints(svc.endpoints)) service = {'endpoints': eps, 'id': svc.id, 'type': svc.type} service['name'] = svc.extra.get('name', '') return service return [make_v3_service(svc) for svc in services]
def get_network_ports(context, network_id): try: return (context.session.query(models_v2.Port). filter(models_v2.Port.network_id == network_id, models_v2.Port.admin_state_up == sql.true()).all()) except exc.NoResultFound: return
def schedule_unscheduled_bgp_speakers(self, context, host): """Schedule unscheduled BgpSpeaker to a BgpDrAgent. """ LOG.debug('Started auto-scheduling on host %s', host) with context.session.begin(subtransactions=True): query = context.session.query(agents_db.Agent) query = query.filter_by( agent_type=bgp_consts.AGENT_TYPE_BGP_ROUTING, host=host, admin_state_up=sql.true()) try: bgp_dragent = query.one() except (exc.NoResultFound): LOG.debug('No enabled BgpDrAgent on host %s', host) return False if agents_db.AgentDbMixin.is_agent_down( bgp_dragent.heartbeat_timestamp): LOG.warning(_LW('BgpDrAgent %s is down'), bgp_dragent.id) return False if self._is_bgp_speaker_hosted(context, bgp_dragent['id']): # One BgpDrAgent can only host one BGP speaker LOG.debug('BgpDrAgent already hosting a speaker on host %s. ' 'Cannot schedule an another one', host) return False unscheduled_speakers = self._get_unscheduled_bgp_speakers(context) if not unscheduled_speakers: LOG.debug('Nothing to auto-schedule on host %s', host) return False self.bind(context, [bgp_dragent], unscheduled_speakers[0]) return True
def _get_default_external_network(self, context): """Get the default external network for the deployment.""" with context.session.begin(subtransactions=True): default_external_networks = ( context.session.query(ext_net_models.ExternalNetwork) .filter_by(is_default=sql.true()) .join(models_v2.Network) .join(standard_attr.StandardAttribute) .order_by(standard_attr.StandardAttribute.id) .all() ) if not default_external_networks: LOG.error( _LE( "Unable to find default external network " "for deployment, please create/assign one to " "allow auto-allocation to work correctly." ) ) raise exceptions.AutoAllocationFailure(reason=_("No default router:external network")) if len(default_external_networks) > 1: LOG.error( _LE("Multiple external default networks detected. " "Network %s is true 'default'."), default_external_networks[0]["network_id"], ) return default_external_networks[0].network_id
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query query_filter = None if self.model_query_scope(context, model): if hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for _name, hooks in self._model_query_hooks.get(model, {}).iteritems(): query_hook = hooks.get('query') if isinstance(query_hook, six.string_types): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, six.string_types): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
def has_property(cls, prop, when=None): # TODO Use joins property_granted_select = select( [null()], from_obj=[ Property.__table__, PropertyGroup.__table__, Membership.__table__ ] ).where( and_( Property.name == prop, Property.property_group_id == PropertyGroup.id, PropertyGroup.id == Membership.group_id, Membership.user_id == cls.id, Membership.active(when) ) ) #.cte("property_granted_select") return and_( not_(exists( property_granted_select.where( Property.granted == false()) )), exists( property_granted_select.where( Property.granted == true() ) ) ).self_group().label("has_property_" + prop)
def has_property(self, prop): property_granted_select = select( [null()], from_obj=[ Property.__table__, PropertyGroup.__table__, Membership.__table__ ] ).where( and_( Property.name == prop, Property.property_group_id == PropertyGroup.id, PropertyGroup.id == Membership.group_id, Membership.user_id == self.id, Membership.active ) ) #.cte("property_granted_select") return and_( not_(exists( property_granted_select.where( Property.granted == false()) )), exists( property_granted_select.where( Property.granted == true() ) ) )
def upgrade(): op.create_table('trunks', sa.Column('admin_state_up', sa.Boolean(), nullable=False, server_default=sql.true()), sa.Column('tenant_id', sa.String(length=255), nullable=True, index=True), sa.Column('id', sa.String(length=36), nullable=False), sa.Column('name', sa.String(length=255), nullable=True), sa.Column('port_id', sa.String(length=36), nullable=False), sa.Column('status', sa.String(length=16), nullable=False, server_default='ACTIVE'), sa.Column('standard_attr_id', sa.BigInteger(), nullable=False), sa.ForeignKeyConstraint(['port_id'], ['ports.id'], ondelete='CASCADE'), sa.ForeignKeyConstraint(['standard_attr_id'], ['standardattributes.id'], ondelete='CASCADE'), sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('port_id'), sa.UniqueConstraint('standard_attr_id') ) op.create_table('subports', sa.Column('port_id', sa.String(length=36)), sa.Column('trunk_id', sa.String(length=36), nullable=False), sa.Column('segmentation_type', sa.String(length=32), nullable=False), sa.Column('segmentation_id', sa.Integer(), nullable=False), sa.ForeignKeyConstraint(['port_id'], ['ports.id'], ondelete='CASCADE'), sa.ForeignKeyConstraint(['trunk_id'], ['trunks.id'], ondelete='CASCADE'), sa.PrimaryKeyConstraint('port_id'), sa.UniqueConstraint('trunk_id', 'segmentation_type', 'segmentation_id', name='uniq_subport0trunk_id0segmentation_type0segmentation_id') )
def get_v3_catalog(self, user_id, tenant_id, metadata=None): d = dict(itertools.chain(six.iteritems(CONF), six.iteritems(CONF.eventlet_server))) d.update({"tenant_id": tenant_id, "user_id": user_id}) session = sql.get_session() services = ( session.query(Service).filter(Service.enabled == true()).options(sql.joinedload(Service.endpoints)).all() ) def make_v3_endpoints(endpoints): for endpoint in (ep.to_dict() for ep in endpoints if ep.enabled): del endpoint["service_id"] del endpoint["legacy_endpoint_id"] del endpoint["enabled"] endpoint["region"] = endpoint["region_id"] try: endpoint["url"] = core.format_url(endpoint["url"], d) except exception.MalformedEndpoint: continue # this failure is already logged in format_url() yield endpoint def make_v3_service(svc): eps = list(make_v3_endpoints(svc.endpoints)) service = {"endpoints": eps, "id": svc.id, "type": svc.type} service["name"] = svc.extra.get("name", "") return service return [make_v3_service(svc) for svc in services]
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query # NOTE(jkoelker) non-admin queries are scoped to their tenant_id # NOTE(salvatore-orlando): unless the model allows for shared objects query_filter = None if not context.is_admin and hasattr(model, 'tenant_id'): if hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for _name, hooks in self._model_query_hooks.get(model, {}).iteritems(): query_hook = hooks.get('query') if isinstance(query_hook, basestring): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, basestring): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
def get_ha_routers_l3_agents_count(self, context): """Return a map between HA routers and how many agents every router is scheduled to. """ # Postgres requires every column in the select to be present in # the group by statement when using an aggregate function. # One solution is to generate a subquery and join it with the desired # columns. binding_model = l3_sch_db.RouterL3AgentBinding sub_query = (context.session.query( binding_model.router_id, func.count(binding_model.router_id).label('count')). join(l3_attrs_db.RouterExtraAttributes, binding_model.router_id == l3_attrs_db.RouterExtraAttributes.router_id). join(l3_db.Router). filter(l3_attrs_db.RouterExtraAttributes.ha == sql.true()). group_by(binding_model.router_id).subquery()) query = (context.session.query(l3_db.Router, sub_query.c.count). join(sub_query)) return [(self._make_router_dict(router), agent_count) for router, agent_count in query]
def _get_by_disabled_from_db(context, disabled): if disabled: return context.session.query(api_models.CellMapping).filter_by( disabled=true()).order_by(asc(api_models.CellMapping.id)).all() else: return context.session.query(api_models.CellMapping).filter_by( disabled=false()).order_by(asc( api_models.CellMapping.id)).all()
def test_true_false(self): self.assert_compile( sql.false(), "0" ) self.assert_compile( sql.true(), "1" )
def get_catalog(self, user_id, tenant_id): """Retrieve and format the V2 service catalog. :param user_id: The id of the user who has been authenticated for creating service catalog. :param tenant_id: The id of the project. 'tenant_id' will be None in the case this being called to create a catalog to go in a domain scoped token. In this case, any endpoint that requires a tenant_id as part of their URL will be skipped (as would a whole service if, as a consequence, it has no valid endpoints). :returns: A nested dict representing the service catalog or an empty dict. """ substitutions = dict( itertools.chain(CONF.items(), CONF.eventlet_server.items())) substitutions.update({'user_id': user_id}) silent_keyerror_failures = [] if tenant_id: substitutions.update({'tenant_id': tenant_id}) else: silent_keyerror_failures = ['tenant_id'] session = sql.get_session() endpoints = (session.query(Endpoint). options(sql.joinedload(Endpoint.service)). filter(Endpoint.enabled == true()).all()) catalog = {} for endpoint in endpoints: if not endpoint.service['enabled']: continue try: formatted_url = core.format_url( endpoint['url'], substitutions, silent_keyerror_failures=silent_keyerror_failures) if formatted_url is not None: url = formatted_url else: continue except exception.MalformedEndpoint: continue # this failure is already logged in format_url() region = endpoint['region_id'] service_type = endpoint.service['type'] default_service = { 'id': endpoint['id'], 'name': endpoint.service.extra.get('name', ''), 'publicURL': '' } catalog.setdefault(region, {}) catalog[region].setdefault(service_type, default_service) interface_url = '%sURL' % endpoint['interface'] catalog[region][service_type][interface_url] = url return catalog
def get_v3_catalog(self, user_id, tenant_id): """Retrieve and format the current V3 service catalog. :param user_id: The id of the user who has been authenticated for creating service catalog. :param tenant_id: The id of the project. 'tenant_id' will be None in the case this being called to create a catalog to go in a domain scoped token. In this case, any endpoint that requires a tenant_id as part of their URL will be skipped. :returns: A list representing the service catalog or an empty list """ d = dict( itertools.chain(CONF.items(), CONF.eventlet_server.items())) d.update({'user_id': user_id}) silent_keyerror_failures = [] if tenant_id: d.update({ 'tenant_id': tenant_id, 'project_id': tenant_id, }) else: silent_keyerror_failures = ['tenant_id', 'project_id', ] session = sql.get_session() services = (session.query(Service).filter(Service.enabled == true()). options(sql.joinedload(Service.endpoints)). all()) def make_v3_endpoints(endpoints): for endpoint in (ep.to_dict() for ep in endpoints if ep.enabled): del endpoint['service_id'] del endpoint['legacy_endpoint_id'] del endpoint['enabled'] endpoint['region'] = endpoint['region_id'] try: formatted_url = core.format_url( endpoint['url'], d, silent_keyerror_failures=silent_keyerror_failures) if formatted_url: endpoint['url'] = formatted_url else: continue except exception.MalformedEndpoint: continue # this failure is already logged in format_url() yield endpoint # TODO(davechen): If there is service with no endpoints, we should skip # the service instead of keeping it in the catalog, see bug #1436704. def make_v3_service(svc): eps = list(make_v3_endpoints(svc.endpoints)) service = {'endpoints': eps, 'id': svc.id, 'type': svc.type} service['name'] = svc.extra.get('name', '') return service return [make_v3_service(svc) for svc in services]
def test_twelve(self): c = column('x', Boolean) # I don't have a solution for this one yet, # other than adding some heavy-handed conditionals # into compiler self.assert_compile( c.is_(true()), "x IS 1", dialect=self._dialect(False) )
def _flavor_get_query_from_db(context): query = context.session.query(api_models.Flavors).\ options(joinedload('extra_specs')) if not context.is_admin: the_filter = [api_models.Flavors.is_public == true()] the_filter.extend([ api_models.Flavors.projects.any(project_id=context.project_id) ]) query = query.filter(or_(*the_filter)) return query
def _flavor_get_query(context, session=None, read_deleted=None): query = model_query(context, models.InstanceTypes, session=session, read_deleted=read_deleted) if not context.is_admin: the_filter = [models.InstanceTypes.is_public == true()] the_filter.extend([ models.InstanceTypes.projects.any(project_id=context.project_id) ]) query = query.filter(or_(*the_filter)) return query
def remove_expired_reservations(context, tenant_id=None): now = utcnow() resv_query = context.session.query(quota_models.Reservation) if tenant_id: tenant_expr = (quota_models.Reservation.tenant_id == tenant_id) else: tenant_expr = sql.true() resv_query = resv_query.filter(sa.and_( tenant_expr, quota_models.Reservation.expiration < now)) return resv_query.delete()
def get_network_ports(self, session, network_id): with session.begin(subtransactions=True): query = session.query(ml2_models.PortBinding, agents_db.Agent) query = query.join(agents_db.Agent, agents_db.Agent.host == ml2_models.PortBinding.host) query = query.join(models_v2.Port) query = query.filter( models_v2.Port.network_id == network_id, models_v2.Port.admin_state_up == sql.true(), agents_db.Agent.agent_type.in_(l2_const.SUPPORTED_AGENT_TYPES), ) return query
def get_for_webhook_rebuild(cls, copr_id, webhook_secret, clone_url, commits): packages = (models.Package.query.join(models.Copr) .filter(models.Copr.webhook_secret == webhook_secret) .filter(models.Package.copr_id == copr_id) .filter(models.Package.webhook_rebuild == true()) .filter(models.Package.source_json.contains(clone_url))) result = [] for package in packages: if cls.commits_belong_to_package(package, commits): result += [package] return result
def test_const_expr_role(self): t = true() is_(expect(roles.ConstExprRole, t), t) f = false() is_(expect(roles.ConstExprRole, f), f) is_instance_of(expect(roles.ConstExprRole, True), True_) is_instance_of(expect(roles.ConstExprRole, False), False_) is_instance_of(expect(roles.ConstExprRole, None), Null)
def delete_expired(cls, context, now, project_id): resv_query = context.session.query(models.Reservation) if project_id: project_expr = (models.Reservation.project_id == project_id) else: project_expr = sql.true() # TODO(manjeets) Fetch and delete objects using # object/db/api.py once comparison operations are # supported resv_query = resv_query.filter(sa.and_( project_expr, models.Reservation.expiration < now)) return resv_query.delete()
def distributed_schedule_networks(self, context, **kargs): """Distributed schedule network to hosts who hosting vms belong to the network""" host = kargs.get('host') plugin = manager.NeutronManager.get_plugin() bindings_to_add = [] LOG.debug('distributed_schedule_networks, host:%s', host) with context.session.begin(subtransactions=True): agent = plugin.get_enabled_agent_on_host(context, constants.AGENT_TYPE_DHCP, host) if not agent: return False nets = plugin.list_networks_on_dhcp_agent(context, agent.id) all_net_ids = set(n['id'] for n in nets['networks']) LOG.debug('distributed_schedule_networks, all_net_ids:%s', all_net_ids) fields = ['network_id', 'enable_dhcp'] subnets = plugin.get_subnets(context, fields=fields) dhcp_net_ids = set(s['network_id'] for s in subnets if s['enable_dhcp']) LOG.debug('distributed_schedule_networks, dhcp_net_ids:%s', dhcp_net_ids) """get net-ids by vms' host-id in current host""" filters = {'binding:host_id': [agent.host]} fields = ['network_id'] ports = plugin.get_ports(context, filters = filters, fields = fields) host_net_ids = set(p['network_id'] for p in ports) need_binding_net_ids = dhcp_net_ids & host_net_ids for net_id in all_net_ids - need_binding_net_ids: try: plugin.remove_network_from_dhcp_agent(context, agent.id, net_id) except dhcpagentscheduler.NetworkNotHostedByDhcpAgent: LOG.warning(_('NetworkNotHostedByDhcpAgent,netid:%s, host:%s'), net_id, agent.host) query = context.session.query(agents_db.Agent) query = query.filter(agents_db.Agent.agent_type == constants.AGENT_TYPE_DHCP, agents_db.Agent.host == agent.host, agents_db.Agent.admin_state_up == sql.true()) dhcp_agents = query.all() if dhcp_agents and len(dhcp_agents) == 1: dhcp_agent = dhcp_agents[0] if not agents_db.AgentDbMixin.is_agent_down(dhcp_agent.heartbeat_timestamp): for net_id in need_binding_net_ids: bindings_to_add.append((dhcp_agent, net_id)) else: LOG.error(_('DHCP agent on host %s is not active'), dhcp_agent.host) else: LOG.error(_('No DHCP agent for host %s', agent.host)) for agent, net_id in bindings_to_add: self._schedule_bind_network(context, [agent], net_id) return True
def auto_schedule_networks(self, plugin, context, host): """Schedule non-hosted networks to the DHCP agent on the specified host. """ agents_per_network = cfg.CONF.dhcp_agents_per_network dhcp_network_filter = cfg.CONF.dhcp_network_filter # a list of (agent, net_ids) tuples bindings_to_add = [] with context.session.begin(subtransactions=True): fields = ['network_id', 'enable_dhcp'] subnets = plugin.get_subnets(context, fields=fields) net_ids = set(s['network_id'] for s in subnets if s['enable_dhcp']) #Modify by FSO, for supported FM. if dhcp_network_filter: filter_net_ids = set() for id in net_ids: network = plugin.get_network(context, id) if network['name'] in dhcp_network_filter: filter_net_ids.add(id) net_ids = filter_net_ids if not net_ids: LOG.debug(_('No non-hosted networks')) return False query = context.session.query(agents_db.Agent) query = query.filter(agents_db.Agent.agent_type == constants.AGENT_TYPE_DHCP, agents_db.Agent.host == host, agents_db.Agent.admin_state_up == sql.true()) dhcp_agents = query.all() for dhcp_agent in dhcp_agents: if agents_db.AgentDbMixin.is_agent_down( dhcp_agent.heartbeat_timestamp): LOG.warn(_('DHCP agent %s is not active'), dhcp_agent.id) continue for net_id in net_ids: agents = plugin.get_dhcp_agents_hosting_networks( context, [net_id], active=True) if len(agents) >= agents_per_network: continue if any(dhcp_agent.id == agent.id for agent in agents): continue bindings_to_add.append((dhcp_agent, net_id)) # do it outside transaction so particular scheduling results don't # make other to fail for agent, net_id in bindings_to_add: self._schedule_bind_network(context, [agent], net_id) return True
def flavor_get(self, context, flavor_uuid): query = model_query(context, models.Flavors).filter_by(uuid=flavor_uuid) if not context.is_admin: query = query.filter_by(disabled=False) the_filter = [models.Flavors.is_public == true()] the_filter.extend( [models.Flavors.projects.has(project_id=context.project_id)]) query = query.filter(or_(*the_filter)) try: return query.one() except NoResultFound: raise exception.FlavorNotFound(flavor_id=flavor_uuid)
def get_dvr_network_ports(self, session, network_id): with session.begin(subtransactions=True): query = session.query(ml2_models.DVRPortBinding, agents_db.Agent) query = query.join(agents_db.Agent, agents_db.Agent.host == ml2_models.DVRPortBinding.host) query = query.join(models_v2.Port) query = query.filter(models_v2.Port.network_id == network_id, models_v2.Port.admin_state_up == sql.true(), models_v2.Port.device_owner == const.DEVICE_OWNER_DVR_INTERFACE, agents_db.Agent.agent_type.in_( l2_const.SUPPORTED_AGENT_TYPES)) return query
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query # NOTE(jkoelker) non-admin queries are scoped to their tenant_id # NOTE(salvatore-orlando): unless the model allows for shared objects # ###-------- alter by xm and zyk at 2015.9.23-------------- # query_filter = None # if not context.is_admin and hasattr(model, 'tenant_id'): # if hasattr(model, 'shared'): # query_filter = ((model.tenant_id == context.tenant_id) | # (model.shared == sql.true())) # else: # query_filter = (model.tenant_id == context.tenant_id) ###--change to as follow (because of gcloud7 access controller:gc_resource_type=0/1 0isOwnerAndShared 1isAll)--: query_filter = None if context.gc_resource_type == '0' and hasattr(model, 'user_id'): if hasattr(model, 'shared'): query_filter = ((model.user_id == context.user_id) | (model.shared == sql.true()) | (model.user_id == None)) else: query_filter = ((model.user_id == context.user_id) | (model.user_id == None)) #model.user_id ==None(can not change as model.user_id is None) added # because of such as network:dhcp Ports(which user_id is None) ###------------- end by xm and zyk-------------------------------- # Execute query hooks registered from mixins and plugins for _name, hooks in self._model_query_hooks.get(model, {}).iteritems(): query_hook = hooks.get('query') if isinstance(query_hook, basestring): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, basestring): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
def query_with_hooks(context, model, field=None): """Query with hooks using the said context and model. :param context: The context to use for the DB session. :param model: The model to query. :param field: The column. :returns: The query with hooks applied to it. """ if field: if hasattr(model, field): field = getattr(model, field) else: msg = _("'%s' is not supported as field") % field raise n_exc.InvalidInput(error_message=msg) query = context.session.query(field) else: query = context.session.query(model) # define basic filter condition for model query query_filter = None if db_utils.model_query_scope_is_project(context, model): if hasattr(model, 'rbac_entries'): query = query.outerjoin(model.rbac_entries) rbac_model = model.rbac_entries.property.mapper.class_ query_filter = ( (model.tenant_id == context.tenant_id) | ((rbac_model.action == 'access_as_shared') & ((rbac_model.target_tenant == context.tenant_id) | (rbac_model.target_tenant == '*')))) elif hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for hook in get_hooks(model): query_hook = helpers.resolve_ref(hook.get('query')) if query_hook: query = query_hook(context, model, query) filter_hook = helpers.resolve_ref(hook.get('filter')) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
class Vim(model_base.BASE, models_v1.HasId, models_v1.HasTenant, models_v1.Audit): type = sa.Column(sa.String(64), nullable=False) name = sa.Column(sa.String(255), nullable=False) description = sa.Column(sa.Text, nullable=True) placement_attr = sa.Column(types.Json, nullable=True) shared = sa.Column(sa.Boolean, default=True, server_default=sql.true(), nullable=False) is_default = sa.Column(sa.Boolean, default=False, server_default=sql.false(), nullable=False) vim_auth = orm.relationship('VimAuth') status = sa.Column(sa.String(255), nullable=False)
class SecurityGroup(standard_attr.HasStandardAttributes, model_base.BASEV2, model_base.HasId, model_base.HasProject): """Represents a v2 neutron security group.""" name = sa.Column(sa.String(db_const.NAME_FIELD_SIZE)) stateful = sa.Column(sa.Boolean, default=True, server_default=sql.true(), nullable=False) rbac_entries = sa.orm.relationship(rbac_db_models.SecurityGroupRBAC, backref='security_group', lazy='subquery', cascade='all, delete, delete-orphan') api_collections = [sg.SECURITYGROUPS] collection_resource_map = {sg.SECURITYGROUPS: 'security_group'} tag_support = True
def get_enabled_agent_on_host(self, context, agent_type, host): """Return agent of agent_type for the specified host.""" query = context.session.query(Agent) query = query.filter(Agent.agent_type == agent_type, Agent.host == host, Agent.admin_state_up == sql.true()) try: agent = query.one() except exc.NoResultFound: LOG.debug('No enabled %(agent_type)s agent on host ' '%(host)s', {'agent_type': agent_type, 'host': host}) return if self.is_agent_down(agent.heartbeat_timestamp): LOG.warning(_LW('%(agent_type)s agent %(agent_id)s is not active'), {'agent_type': agent_type, 'agent_id': agent.id}) return agent
def auto_schedule_networks(self, plugin, context, host): """Schedule non-hosted networks to the DHCP agent on the specified host. """ agents_per_network = cfg.CONF.dhcp_agents_per_network # a list of (agent, net_ids) tuples bindings_to_add = [] with context.session.begin(subtransactions=True): fields = ['network_id', 'enable_dhcp'] subnets = plugin.get_subnets(context, fields=fields) net_ids = set(s['network_id'] for s in subnets if s['enable_dhcp']) if not net_ids: LOG.debug('No non-hosted networks') return False query = context.session.query(agents_db.Agent) query = query.filter(agents_db.Agent.agent_type == constants.AGENT_TYPE_DHCP, agents_db.Agent.host == host, agents_db.Agent.admin_state_up == sql.true()) dhcp_agents = query.all() for dhcp_agent in dhcp_agents: if agents_db.AgentDbMixin.is_agent_down( dhcp_agent.heartbeat_timestamp): LOG.warning(_LW('DHCP agent %s is not active'), dhcp_agent.id) continue for net_id in net_ids: agents = plugin.get_dhcp_agents_hosting_networks( context, [net_id]) if len(agents) >= agents_per_network: continue if any(dhcp_agent.id == agent.id for agent in agents): continue net = plugin.get_network(context, net_id) az_hints = (net.get(az_ext.AZ_HINTS) or cfg.CONF.default_availability_zones) if (az_hints and dhcp_agent['availability_zone'] not in az_hints): continue bindings_to_add.append((dhcp_agent, net_id)) # do it outside transaction so particular scheduling results don't # make other to fail for agent, net_id in bindings_to_add: self.resource_filter.bind(context, [agent], net_id) return True
class HeadlineModel(db.Model): __tablename__ = 'headline' id = db.Column(db.Integer, primary_key=True) user_id = db.Column(db.Integer(), nullable=False, index=True) title = db.Column(db.Unicode(512), nullable=False) url = db.Column(db.Unicode(512)) is_display = db.Column(db.Boolean, default=True, server_default=sql.true(), nullable=False, index=True) date_created = db.Column(db.DateTime, nullable=False, index=True, server_default=db.func.current_timestamp()) def as_dict(self): return { 'id': self.id, 'title': self.title, } @staticmethod def generate_fake(count=100): from sqlalchemy.exc import IntegrityError from random import seed, randint import forgery_py seed() user_count = UserModel.query.count() if user_count == 0: UserModel.generate_fake() user_count = UserModel.query.count() for i in range(count): u = UserModel.query.offset(randint(0, user_count - 1)).first() h = HeadlineModel(user_id=u.id, title=forgery_py.lorem_ipsum.title()) db.session.add(h) try: db.session.commit() except IntegrityError: db.session.rollback() def __repr__(self): return '<Headline %r>' % self.title
def stop_callback(update: Update, context: CallbackContext, chat_info: dict, _: gettext): if chat_info["is_subscribed"]: Session().query(Chat).filter_by(id=update.message.chat_id).update( {"is_subscribed": false()}) transaction.commit() update.message.reply_text(text=_( "You're unsubscribed. You always can subscribe again 👉 /start")) Session().query(Notification).filter_by( is_active=true(), chat_id=update.message.chat_id).update({"is_active": false()}) transaction.commit() return ConversationHandler.END
class Agent(model_base.BASEV2, model_base.HasId): """Represents agents running in neutron deployments.""" __table_args__ = (sa.UniqueConstraint('agent_type', 'host', name='uniq_agents0agent_type0host'), model_base.BASEV2.__table_args__) # L3 agent, DHCP agent, OVS agent, LinuxBridge agent_type = sa.Column(sa.String(255), nullable=False) binary = sa.Column(sa.String(255), nullable=False) # TOPIC is a fanout exchange topic topic = sa.Column(sa.String(255), nullable=False) # TOPIC.host is a target topic host = sa.Column(sa.String(255), nullable=False, index=True) availability_zone = sa.Column(sa.String(255)) admin_state_up = sa.Column(sa.Boolean, default=True, server_default=sql.true(), nullable=False) # the time when first report came from agents created_at = sa.Column(sa.DateTime, nullable=False) # the time when first report came after agents start started_at = sa.Column(sa.DateTime, nullable=False) # updated when agents report heartbeat_timestamp = sa.Column(sa.DateTime, nullable=False) # description is note for admin user description = sa.Column(sa.String(db_const.DESCRIPTION_FIELD_SIZE)) # configurations: a json dict string, I think 4095 is enough configurations = sa.Column(sa.String(4095), nullable=False) # resource_versions: json dict, 8191 allows for ~256 resource versions # assuming ~32byte length "'name': 'ver'," # the whole row limit is 65535 bytes in mysql resource_versions = sa.Column(sa.String(8191)) # load - number of resources hosted by the agent load = sa.Column(sa.Integer, server_default='0', nullable=False) # resources_synced: nullable boolean, success of last sync to Placement resources_synced = sa.Column(sa.Boolean, default=None, server_default=None, nullable=True) @property def is_active(self): return not utils.is_agent_down(self.heartbeat_timestamp)
def _finish_task_values(memo, elapsed_seconds=None): """ Get values to update when finishing tasks. """ values = { 'is_processed': sa_sql.true(), 'processed': sa_sql.func.now(), 'locked_until': sa_sql.func.now(), } if elapsed_seconds is not None: # we store milliseconds here values['elapsed_seconds'] = elapsed_seconds * 1000 if memo is not None: # Ensure the memo object is JSON serializable, and therefore won't # be rejected by SQLAlchemy, by first marshaling it using 'str' as # the default encoder, then unmarshalling it back to a Python value. values['memo'] = json.loads(json.dumps(memo, default=str)) return values
def has_property(self, prop): property_granted_select = select( [null()], from_obj=[ Property.__table__, PropertyGroup.__table__, Membership.__table__ ]).where( and_(Property.name == prop, Property.property_group_id == PropertyGroup.id, PropertyGroup.id == Membership.group_id, Membership.user_id == self.id, Membership.active)) #.cte("property_granted_select") return and_( not_( exists( property_granted_select.where( Property.granted == false()))), exists(property_granted_select.where(Property.granted == true())))
def _build_solves_query(extra_filters=(), admin_view=False): """Returns queries and data that that are used for showing an account's solves. It returns a tuple of - SQLAlchemy query with (challenge_id, solve_count_for_challenge_id) - Current user's solved challenge IDs """ # This can return None (unauth) if visibility is set to public user = get_current_user() # We only set a condition for matching user solves if there is a user and # they have an account ID (user mode or in a team in teams mode) AccountModel = get_model() if user is not None and user.account_id is not None: user_solved_cond = Solves.account_id == user.account_id else: user_solved_cond = false() # We have to filter solves to exclude any made after the current freeze # time unless we're in an admin view as determined by the caller. freeze = get_config("freeze") if freeze and not admin_view: freeze_cond = Solves.date < unix_time_to_utc(freeze) else: freeze_cond = true() # Finally, we never count solves made by hidden or banned users/teams, even # if we are an admin. This is to match the challenge detail API. exclude_solves_cond = and_( AccountModel.banned == false(), AccountModel.hidden == false(), ) # This query counts the number of solves per challenge, as well as the sum # of correct solves made by the current user per the condition above (which # should probably only be 0 or 1!) solves_q = ( db.session.query(Solves.challenge_id, sa_func.count(Solves.challenge_id),) .join(AccountModel) .filter(*extra_filters, freeze_cond, exclude_solves_cond) .group_by(Solves.challenge_id) ) # Also gather the user's solve items which can be different from above query # Even if we are a hidden user, we should see that we have solved the challenge # But as a hidden user we are not included in the count solve_ids = ( Solves.query.with_entities(Solves.challenge_id).filter(user_solved_cond).all() ) solve_ids = {value for value, in solve_ids} return solves_q, solve_ids
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query # NOTE(jkoelker) non-admin queries are scoped to their tenant_id # NOTE(salvatore-orlando): unless the model allows for shared objects query_filter = None if not context.is_admin and hasattr(model, 'tenant_id'): if hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) elif context.is_admin and hasattr(model, 'tenant_id'): # NOTE(Lijiale) One tenant can not access other tenant's Vim, # NOTE(Lijiale) even though this tenant has admin role. if hasattr(model, 'shared'): query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for _name, hooks in iteritems(self._model_query_hooks.get(model, {})): query_hook = hooks.get('query') if isinstance(query_hook, six.string_types): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, six.string_types): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) # Don't list the deleted entries if hasattr(model, 'deleted_at'): query = query.filter_by(deleted_at=datetime.min) return query
def has_property(cls, prop, when=None): # TODO Use joins property_granted_select = select( [null()], from_obj=[ Property.__table__, PropertyGroup.__table__, Membership.__table__ ]).where( and_(Property.name == prop, Property.property_group_id == PropertyGroup.id, PropertyGroup.id == Membership.group_id, Membership.user_id == cls.id, Membership.active(when))) #.cte("property_granted_select") return and_( not_( exists( property_granted_select.where( Property.granted == false()))), exists(property_granted_select.where(Property.granted == true())) ).self_group().label("has_property_" + prop)
def get_packet_filters_for_port(self, context, port): """Retrieve packet filters on OFC on a given port. It returns a list of tuple (neutron filter_id, OFC id). """ query = (context.session.query(nmodels.OFCFilterMapping) .join(PacketFilter, nmodels.OFCFilterMapping.neutron_id == PacketFilter.id) .filter(PacketFilter.admin_state_up == sql.true())) network_id = port['network_id'] net_pf_query = (query.filter(PacketFilter.network_id == network_id) .filter(PacketFilter.in_port == sql.null())) net_filters = [(pf['neutron_id'], pf['ofc_id']) for pf in net_pf_query] port_pf_query = query.filter(PacketFilter.in_port == port['id']) port_filters = [(pf['neutron_id'], pf['ofc_id']) for pf in port_pf_query] return net_filters + port_filters
def test_deletion_three_offline_nodes_and_one_online(self): cluster = self.env.create( nodes_kwargs=[ {"online": False, "pending_deletion": True}, {"online": False, "pending_deletion": True}, {"online": False, "pending_deletion": True}, {"online": True, "pending_deletion": True} ] ) supertask = self.env.launch_deployment() self.db.flush() self.env.wait_ready(supertask, timeout=5) # this test is failing when whole test set is executing # apparently the main reason for that is delays in data # updating inside of fake threads so in order to make test # pass we have to wait for data to be present in db self.env.wait_for_true(self.check_node_presence, args=[1]) # Offline nodes were deleted, online node came back self.assertEqual( self.db.query(models.Node).filter( models.Node.cluster_id == cluster['id']).count(), 0 ) self.assertEqual( self.db.query(models.Node).filter( models.Node.cluster_id.is_(None)).count(), 1 ) self.assertEqual( self.db.query(models.Node).filter( models.Node.status == NODE_STATUSES.discover).count(), 1 ) self.assertEqual( self.db.query(models.Node).filter( models.Node.online == sql.true()).count(), 1 )
def _check_untagged_builds(session, collection, package_map, build_infos): """ Check whether some of the builds we have weren't untagged/deleted in the meantime. Only checks last builds of packages. """ for info in build_infos: package = package_map.get(info['package_name']) # info contains the last build for the package that Koji knows if package and util.is_build_newer(info, package.last_build): # The last build (possibly more) we have is newer than last build in Koji. # That means it was untagged or deleted. # Get the last build we have that was not untagged. last_valid_build_query = ( session.db.query(Build) .filter( (Build.package_id == package.id) & (Build.epoch == info['epoch']) & (Build.version == info['version']) & (Build.release == info['release']) ) .order_by(Build.started.desc()) ) last_valid_build = last_valid_build_query.first() if not last_valid_build: # We don't have the build anymore, register it again register_real_builds(session, collection, [(package.id, info)]) # Now, it must find it as we've just inserted it last_valid_build = last_valid_build_query.first() # set all following builds as untagged # last_build pointers get reset by the trigger ( session.db.query(Build) .filter(Build.package_id == package.id) .filter( Build.started > last_valid_build.started if last_valid_build else true() ) .update({'untagged': True}) ) session.log.info("{} is no longer tagged".format(package.last_build))
def filter_timestamp_column(self, ts_col, cmp_op: callable) -> ColumnElement: """ Filter timestamp column by comparing to this hour-of-day using the given comparison operator. Note that for the class `MissingHourAndMinutesTimestamp` this always returns TRUE, since a missing timestamp imposes no constraint. Parameters ---------- ts_col : sqlalchemy column The timestamp column to filter. cmp_op : callable Comparison operator to use. For example: `operator.lt`, `operator.ge`. Returns ------- sqlalchemy.sql.elements.True_ """ return true()
class Vim(model_base.BASE, models_v1.HasId, models_v1.HasTenant, models_v1.Audit): type = sa.Column(sa.String(64), nullable=False) name = sa.Column(sa.String(255), nullable=False) description = sa.Column(sa.Text, nullable=True) placement_attr = sa.Column(types.Json, nullable=True) shared = sa.Column(sa.Boolean, default=True, server_default=sql.true( ), nullable=False) is_default = sa.Column(sa.Boolean, default=False, server_default=sql.false( ), nullable=False) vim_auth = orm.relationship('VimAuth') status = sa.Column(sa.String(255), nullable=False) __table_args__ = ( schema.UniqueConstraint( "tenant_id", "name", name="uniq_vim0tenant_id0name"), )
def _get_default_external_network(self, context): """Get the default external network for the deployment.""" with context.session.begin(subtransactions=True): default_external_networks = (context.session.query( external_net_db.ExternalNetwork). filter_by(is_default=sql.true()). join(models_v2.Network). join(model_base.StandardAttribute). order_by(model_base.StandardAttribute.id).all()) if not default_external_networks: LOG.error(_LE("Unable to find default external network " "for deployment, please create/assign one to " "allow auto-allocation to work correctly.")) raise exceptions.AutoAllocationFailure( reason=_("No default router:external network")) if len(default_external_networks) > 1: LOG.error(_LE("Multiple external default networks detected. " "Network %s is true 'default'."), default_external_networks[0]['network_id']) return default_external_networks[0]
def get_pending_build_tasks(cls, background=None): query = (models.BuildChroot.query.outerjoin(models.Build).outerjoin( models.CoprDir).outerjoin( models.Package, models.Package.id == models.Build.package_id).options( joinedload('build').joinedload('copr_dir'), joinedload('build').joinedload('package') ).filter(models.Build.canceled == false()).filter( or_( models.BuildChroot.status == StatusEnum("pending"), and_( models.BuildChroot.status == StatusEnum("running"), models.BuildChroot.started_on < int(time.time() - 1.1 * MAX_BUILD_TIMEOUT), models.BuildChroot.ended_on.is_(None)))).order_by( models.Build.is_background.asc(), models.Build.id.asc())) if background is not None: query = query.filter(models.Build.is_background == ( true() if background else false())) return query
class Trunk(model_base.HasStandardAttributes, model_base.BASEV2, model_base.HasId, model_base.HasProject): admin_state_up = sa.Column( sa.Boolean(), nullable=False, server_default=sql.true()) name = sa.Column(sa.String(attributes.NAME_MAX_LEN)) port_id = sa.Column(sa.String(36), sa.ForeignKey('ports.id', ondelete='CASCADE'), nullable=False, unique=True) status = sa.Column( sa.String(16), nullable=False, server_default=constants.ACTIVE_STATUS) port = sa.orm.relationship( models_v2.Port, backref=sa.orm.backref('trunk_port', lazy='joined', uselist=False, cascade='delete')) sub_ports = sa.orm.relationship( 'SubPort', lazy='joined', uselist=True, cascade="all, delete-orphan")
def get_ha_routers_l3_agents_count(self, context): """Return a map between HA routers and how many agents every router is scheduled to. """ # Postgres requires every column in the select to be present in # the group by statement when using an aggregate function. # One solution is to generate a subquery and join it with the desired # columns. binding_model = l3_sch_db.RouterL3AgentBinding sub_query = (context.session.query( binding_model.router_id, func.count(binding_model.router_id).label('count')).join( l3_attrs_db.RouterExtraAttributes, binding_model.router_id == l3_attrs_db.RouterExtraAttributes. router_id).join(l3_db.Router).filter( l3_attrs_db.RouterExtraAttributes.ha == sql.true()).group_by(binding_model.router_id).subquery()) query = (context.session.query(l3_db.Router.id, l3_db.Router.tenant_id, sub_query.c.count).join(sub_query)) return query
def upgrade(): op.create_table( 'trunks', sa.Column('admin_state_up', sa.Boolean(), nullable=False, server_default=sql.true()), sa.Column('tenant_id', sa.String(length=255), nullable=True, index=True), sa.Column('id', sa.String(length=36), nullable=False), sa.Column('name', sa.String(length=255), nullable=True), sa.Column('port_id', sa.String(length=36), nullable=False), sa.Column('status', sa.String(length=16), nullable=False, server_default='ACTIVE'), sa.Column('standard_attr_id', sa.BigInteger(), nullable=False), sa.ForeignKeyConstraint(['port_id'], ['ports.id'], ondelete='CASCADE'), sa.ForeignKeyConstraint(['standard_attr_id'], ['standardattributes.id'], ondelete='CASCADE'), sa.PrimaryKeyConstraint('id'), sa.UniqueConstraint('port_id'), sa.UniqueConstraint('standard_attr_id')) op.create_table( 'subports', sa.Column('port_id', sa.String(length=36)), sa.Column('trunk_id', sa.String(length=36), nullable=False), sa.Column('segmentation_type', sa.String(length=32), nullable=False), sa.Column('segmentation_id', sa.Integer(), nullable=False), sa.ForeignKeyConstraint(['port_id'], ['ports.id'], ondelete='CASCADE'), sa.ForeignKeyConstraint(['trunk_id'], ['trunks.id'], ondelete='CASCADE'), sa.PrimaryKeyConstraint('port_id'), sa.UniqueConstraint( 'trunk_id', 'segmentation_type', 'segmentation_id', name='uniq_subport0trunk_id0segmentation_type0segmentation_id'))
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query query_filter = None if self.model_query_scope(context, model): # ★这个权限范围判断很重要 ★ if hasattr(model, 'rbac_entries'): # model有没有rbac_entries这个属性 query = query.outerjoin(model.rbac_entries) rbac_model = model.rbac_entries.property.mapper.class_ query_filter = ( (model.tenant_id == context.tenant_id) | ((rbac_model.action == 'access_as_shared') & ((rbac_model.target_tenant == context.tenant_id) | (rbac_model.target_tenant == '*')))) elif hasattr(model, 'shared'): # 有没有shared这个属性 query_filter = ((model.tenant_id == context.tenant_id) | # 条件就是:同租户或者shared为true (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # 条件为:同租户 # Execute query hooks registered from mixins and plugins for _name, hooks in six.iteritems(self._model_query_hooks.get(model, # model专属的过滤钩子 {})): query_hook = hooks.get('query') if isinstance(query_hook, six.string_types): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, six.string_types): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) # 没有这个query_filter的话就加进去 return query
def _model_query(self, context, model): query = context.session.query(model) # define basic filter condition for model query query_filter = None if self.model_query_scope(context, model): if hasattr(model, 'rbac_entries'): rbac_model, join_params = self._get_rbac_query_params(model) query = query.outerjoin(*join_params) query_filter = ( (model.tenant_id == context.tenant_id) | ((rbac_model.action == 'access_as_shared') & ((rbac_model.target_tenant == context.tenant_id) | (rbac_model.target_tenant == '*')))) elif hasattr(model, 'shared'): query_filter = ((model.tenant_id == context.tenant_id) | (model.shared == sql.true())) else: query_filter = (model.tenant_id == context.tenant_id) # Execute query hooks registered from mixins and plugins for _name, hooks in six.iteritems(self._model_query_hooks.get(model, {})): query_hook = hooks.get('query') if isinstance(query_hook, six.string_types): query_hook = getattr(self, query_hook, None) if query_hook: query = query_hook(context, model, query) filter_hook = hooks.get('filter') if isinstance(filter_hook, six.string_types): filter_hook = getattr(self, filter_hook, None) if filter_hook: query_filter = filter_hook(context, model, query_filter) # NOTE(salvatore-orlando): 'if query_filter' will try to evaluate the # condition, raising an exception if query_filter is not None: query = query.filter(query_filter) return query
class PermissionGroup(db.Base): __tablename__ = 'permission_groups' __table_args__ = {'extend_existing': True} id = Column(Integer, primary_key=True) name = Column(String, unique=True) trade = Column(Boolean, server_default=sql.false()) deposit = Column(Boolean, server_default=sql.false()) withdraw = Column(Boolean, server_default=sql.false()) login = Column(Boolean, server_default=sql.true()) full_ui = Column(Boolean, server_default=sql.false()) def __init__(self, name, permissions): """ :param name: :type name: str """ self.name = name self.trade = 'trade' in permissions self.withdraw = 'withdraw' in permissions self.deposit = 'deposit' in permissions self.login = '******' in permissions self.full_ui = 'full_ui' in permissions @property def dict(self): return {'name': self.name, 'trade': self.trade, 'deposit': self.deposit, 'withdraw': self.withdraw, 'login': self.login, 'full_ui': self.full_ui } def __repr__(self): return "<PermissionGroup('%s')>" % self.dict
class Agent(model_base.BASEV2, models_v2.HasId): """Represents agents running in neutron deployments.""" __table_args__ = (sa.UniqueConstraint('agent_type', 'host', name='uniq_agents0agent_type0host'), model_base.BASEV2.__table_args__) # L3 agent, DHCP agent, OVS agent, LinuxBridge agent_type = sa.Column(sa.String(255), nullable=False) binary = sa.Column(sa.String(255), nullable=False) # TOPIC is a fanout exchange topic topic = sa.Column(sa.String(255), nullable=False) # TOPIC.host is a target topic host = sa.Column(sa.String(255), nullable=False) availability_zone = sa.Column(sa.String(255)) admin_state_up = sa.Column(sa.Boolean, default=True, server_default=sql.true(), nullable=False) # the time when first report came from agents created_at = sa.Column(sa.DateTime, nullable=False) # the time when first report came after agents start started_at = sa.Column(sa.DateTime, nullable=False) # updated when agents report heartbeat_timestamp = sa.Column(sa.DateTime, nullable=False) # description is note for admin user description = sa.Column(sa.String(255)) # configurations: a json dict string, I think 4095 is enough configurations = sa.Column(sa.String(4095), nullable=False) # load - number of resources hosted by the agent load = sa.Column(sa.Integer, server_default='0', nullable=False) @property def is_active(self): return not AgentDbMixin.is_agent_down(self.heartbeat_timestamp)