def update_portbinding(port_id, blade_intf_dn=None, portprofile_name=None,
                       vlan_name=None, vlan_id=None, qos=None,
                       tenant_id=None, instance_id=None,
                       vif_id=None):
    """Updates port binding"""
    LOG.debug("db update_portbinding() called")
    session = db.get_session()
    try:
        port_binding = session.query(ucs_models.PortBinding).\
          filter_by(port_id=port_id).\
          one()
        if blade_intf_dn:
            port_binding.blade_intf_dn = blade_intf_dn
        if portprofile_name:
            port_binding.portprofile_name = portprofile_name
        if vlan_name:
            port_binding.vlan_name = vlan_name
        if vlan_name:
            port_binding.vlan_id = vlan_id
        if qos:
            port_binding.qos = qos
        if tenant_id:
            port_binding.tenant_id = tenant_id
        if instance_id:
            port_binding.instance_id = instance_id
        if vif_id:
            port_binding.vif_id = vif_id
        session.merge(port_binding)
        session.flush()
        return port_binding
    except exc.NoResultFound:
        raise c_exc.PortVnicNotFound(port_id=port_id)

def get_all_credentials(tenant_id):
    """Lists all the creds for a tenant"""
    session = db.get_session()
    try:
        creds = session.query(l2network_models.Credential).filter_by(tenant_id=tenant_id).all()
        return creds
    except exc.NoResultFound:
        return []

def add_services_binding(service_id, mngnet_id, nbnet_id, sbnet_id):
    """Adds a services binding"""
    LOG.debug(_("add_services_binding() called"))
    session = db.get_session()
    binding = services_models.ServicesBinding(service_id, mngnet_id, nbnet_id, sbnet_id)
    session.add(binding)
    session.flush()
    return binding

def add_nexusport_binding(port_id, vlan_id):
    """Adds a nexusport binding"""
    LOG.debug("add_nexusport_binding() called")
    session = db.get_session()
    binding = nexus_models.NexusPortBinding(port_id, vlan_id)
    session.add(binding)
    session.flush()
    return binding

def add_catalystport_binding(port_id, vlan_id):
    """Adds a catalystport binding"""
    LOG.debug("add_catalystport_binding() called")
    session = db.get_session()
    binding = catalyst_models.CatalystPortBinding(port_id, vlan_id)
    session.add(binding)
    session.flush()
    return binding

def get_all_qoss(tenant_id):
    """Lists all the qos to tenant associations"""
    LOG.debug("get_all_qoss() called")
    session = db.get_session()
    try:
        qoss = session.query(l2network_models.QoS).filter_by(tenant_id=tenant_id).all()
        return qoss
    except exc.NoResultFound:
        return []

def get_pp_binding(tenantid, ppid):
    """Lists a port profile binding"""
    LOG.debug("get_pp_binding() called")
    session = db.get_session()
    try:
        binding = session.query(l2network_models.PortProfileBinding).filter_by(portprofile_id=ppid).one()
        return binding
    except exc.NoResultFound:
        return []

def get_portprofile(tenantid, ppid):
    """Lists a port profile"""
    LOG.debug("get_portprofile() called")
    session = db.get_session()
    try:
        pp = session.query(l2network_models.PortProfile).filter_by(uuid=ppid).one()
        return pp
    except exc.NoResultFound:
        raise c_exc.PortProfileNotFound(tenant_id=tenantid, portprofile_id=ppid)

def get_vlan_binding(netid):
    """Lists the vlan given a network_id"""
    LOG.debug("get_vlan_binding() called")
    session = db.get_session()
    try:
        binding = session.query(l2network_models.VlanBinding).filter_by(network_id=netid).one()
        return binding
    except exc.NoResultFound:
        raise q_exc.NetworkNotFound(net_id=netid)

def get_all_portbindings():
    """Lists all the port bindings"""
    LOG.debug("db get_all_portbindings() called")
    session = db.get_session()
    try:
        port_bindings = session.query(ucs_models.PortBinding).all()
        return port_bindings
    except exc.NoResultFound:
        return []

def get_qos(tenant_id, qos_id):
    """Lists the qos given a tenant_id and qos_id"""
    LOG.debug("get_qos() called")
    session = db.get_session()
    try:
        qos = session.query(l2network_models.QoS).filter_by(tenant_id=tenant_id).filter_by(qos_id=qos_id).one()
        return qos
    except exc.NoResultFound:
        raise c_exc.QosNotFound(qos_id=qos_id, tenant_id=tenant_id)

def get_service_bindings(service_id):
    """Lists services bindings for a service_id"""
    LOG.debug(_("get_service_bindings() called"))
    session = db.get_session()
    try:
        bindings = session.query(services_models.ServicesBinding).filter_by(service_id=service_id).one()
        return bindings
    except exc.NoResultFound:
        return []

def get_all_pp_bindings():
    """Lists all the port profiles"""
    LOG.debug("get_all_pp_bindings() called")
    session = db.get_session()
    try:
        bindings = session.query(l2network_models.PortProfileBinding).all()
        return bindings
    except exc.NoResultFound:
        return []

def get_all_services_bindings():
    """Lists all the services bindings"""
    LOG.debug("get_all_services_bindings() called")
    session = db.get_session()
    try:
        bindings = session.query(services_models.ServicesBinding).all()
        return bindings
    except exc.NoResultFound:
        return []

def get_all_nexusport_bindings():
    """Lists all the nexusport bindings"""
    LOG.debug("get_all_nexusport_bindings() called")
    session = db.get_session()
    try:
        bindings = session.query(nexus_models.NexusPortBinding).all()
        return bindings
    except exc.NoResultFound:
        return []

def get_all_portprofiles():
    """Lists all the port profiles"""
    LOG.debug(_("get_all_portprofiles() called"))
    session = db.get_session()
    try:
        pps = session.query(l2network_models.PortProfile).all()
        return pps
    except exc.NoResultFound:
        return []

def get_all_vlanids():
    """Gets all the vlanids"""
    LOG.debug("get_all_vlanids() called")
    session = db.get_session()
    try:
        vlanids = session.query(l2network_models.VlanID).all()
        return vlanids
    except exc.NoResultFound:
        return []

def is_vlanid_used(vlan_id):
    """Checks if a vlanid is in use"""
    LOG.debug("is_vlanid_used() called")
    session = db.get_session()
    try:
        vlanid = session.query(l2network_models.VlanID).filter_by(vlan_id=vlan_id).one()
        return vlanid["vlan_used"]
    except exc.NoResultFound:
        raise c_exc.VlanIDNotFound(vlan_id=vlan_id)

def get_all_vlan_bindings():
    """Lists all the vlan to network associations"""
    LOG.debug("get_all_vlan_bindings() called")
    session = db.get_session()
    try:
        bindings = session.query(l2network_models.VlanBinding).all()
        return bindings
    except exc.NoResultFound:
        return []

def get_all_vlanids_used():
    """Gets all the vlanids used"""
    LOG.debug("get_all_vlanids() called")
    session = db.get_session()
    try:
        vlanids = (session.query(l2network_models.VlanID).
                   filter_by(vlan_used=True).all())
        return vlanids
    except exc.NoResultFound:
        return []