def test_first(self):
db = sqlsoup.SqlSoup(engine)
MappedUsers = db.users
user = db.users.filter(db.users.name == 'Bhargan Basepair').one()
eq_(
user,
MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**',
password=u'basepair',
classname=None,
admin=1))
db.rollback()
user = db.users.get('Bhargan Basepair')
eq_(
user,
MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**',
password=u'basepair',
classname=None,
admin=1))
db.rollback()
user = db.users.filter_by(name='Bhargan Basepair').one()
eq_(
user,
MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**',
password=u'basepair',
classname=None,
admin=1))
db.rollback()
def test_relations(self):
db = sqlsoup.SqlSoup(engine)
db.users.relate('loans', db.loans)
MappedLoans = db.loans
MappedUsers = db.users
eq_(
db.users.get('Joe Student').loans, [
MappedLoans(book_id=1,
user_name=u'Joe Student',
loan_date=datetime.datetime(2006, 7, 12, 0, 0))
])
db.rollback()
eq_(
db.users.filter(~db.users.loans.any()).all(), [
MappedUsers(name=u'Bhargan Basepair',
email='*****@*****.**',
password=u'basepair',
classname=None,
admin=1)
])
db.rollback()
del db._cache['users']
db.users.relate('loans',
db.loans,
order_by=db.loans.loan_date,
cascade='all, delete-orphan')
def test_clear(self):
db = sqlsoup.SqlSoup(engine)
eq_(db.loans.count(), 1)
_ = db.loans.insert(book_id=1, user_name='Bhargan Basepair')
db.expunge_all()
db.flush()
eq_(db.loans.count(), 1)
def test_mapped_join(self):
db = sqlsoup.SqlSoup(engine)
join1 = MappedJoin = db.join(db.users, db.loans, isouter=True)
mj = join1.filter_by(name='Joe Student').all()
eq_(mj, [
MappedJoin(
name=u'Joe Student',
email=u'*****@*****.**',
password=u'student',
classname=None,
admin=0,
book_id=1,
user_name=u'Joe Student',
loan_date=datetime.datetime(2006, 7, 12, 0, 0),
)
])
db.rollback()
join2 = MappedJoin = db.join(join1, db.books)
mj = join2.all()
eq_(mj, [
MappedJoin(
name=u'Joe Student',
email=u'*****@*****.**',
password=u'student',
classname=None,
admin=0,
book_id=1,
user_name=u'Joe Student',
loan_date=datetime.datetime(2006, 7, 12, 0, 0),
id=1,
title=u'Mustards I Have Known',
published_year=u'1989',
authors=u'Jones',
)
])
eq_(
db.with_labels(join1).c.keys(), [
u'users_name',
u'users_email',
u'users_password',
u'users_classname',
u'users_admin',
u'loans_book_id',
u'loans_user_name',
u'loans_loan_date',
])
labeled_loans = db.with_labels(db.loans)
eq_(
db.join(db.users, labeled_loans, isouter=True).c.keys(), [
u'name',
u'email',
u'password',
u'classname',
u'admin',
u'loans_book_id',
u'loans_user_name',
u'loans_loan_date',
])
def test_cls_crud(self):
db = sqlsoup.SqlSoup(engine)
MappedUsers = db.users
db.users.filter_by(name='Bhargan Basepair'
).update(dict(name='Some New Name'))
u1 = db.users.filter_by(name='Some New Name').one()
eq_(u1, MappedUsers(name=u'Some New Name',
email=u'*****@*****.**', password=u'basepair',
classname=None, admin=1))
def test_map_to_no_pk_selectable(self):
db = sqlsoup.SqlSoup(engine)
table = Table('users', db._metadata, Column('id', Integer))
assert_raises_message(sqlsoup.PKNotFoundError,
"table 'users' does not have a primary ",
db.map_to,
'users',
selectable=table)
def test_order_by(self):
db = sqlsoup.SqlSoup(engine)
MappedUsers = db.users
users = db.users.order_by(db.users.name).all()
eq_(users, [MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**', password=u'basepair',
classname=None, admin=1), MappedUsers(name=u'Joe Student',
email=u'*****@*****.**', password=u'student',
classname=None, admin=0)])
def test_map_to_attr_present(self):
db = sqlsoup.SqlSoup(engine)
users = db.users
assert_raises_message(exc.InvalidRequestError,
"Attribute 'users' is already mapped",
db.map_to,
'users',
tablename='users')
def test_map_to_nothing(self):
db = sqlsoup.SqlSoup(engine)
assert_raises_message(
exc.ArgumentError,
"'tablename' or 'selectable' argument is "
"required.",
db.map_to,
'users',
)
def test_dont_persist_alias(self):
db = sqlsoup.SqlSoup(engine)
MappedBooks = db.books
b = db.books._table
s = select([b.c.published_year, func.count('*').label('n')],
from_obj=[b], group_by=[b.c.published_year])
s = s.alias('years_with_count')
years_with_count = db.map(s, primary_key=[s.c.published_year])
assert_raises(exc.InvalidRequestError, years_with_count.insert,
published_year='2007', n=1)
def test_map_to_table_not_string(self):
db = sqlsoup.SqlSoup(engine)
table = Table('users', db._metadata,
Column('id', Integer, primary_key=True))
assert_raises_message(exc.ArgumentError,
"'tablename' argument must be a string.",
db.map_to,
'users',
tablename=table)
def test_map_table(self):
db = sqlsoup.SqlSoup(engine)
users = Table('users', db._metadata, autoload=True)
MappedUsers = db.map(users)
users = MappedUsers.order_by(db.users.name).all()
eq_(users, [MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**', password=u'basepair',
classname=None, admin=1), MappedUsers(name=u'Joe Student',
email=u'*****@*****.**', password=u'student',
classname=None, admin=0)])
def test_map_to_string_not_selectable(self):
db = sqlsoup.SqlSoup(engine)
assert_raises_message(exc.ArgumentError,
"'selectable' argument must be a "
"table, select, join, or other "
"selectable construct.",
db.map_to,
'users',
selectable='users')
def test_selectable(self):
db = sqlsoup.SqlSoup(engine)
MappedBooks = db.books
b = db.books._table
s = select([b.c.published_year, func.count('*').label('n')],
from_obj=[b], group_by=[b.c.published_year])
s = s.alias('years_with_count')
years_with_count = db.map(s, primary_key=[s.c.published_year])
eq_(years_with_count.filter_by(published_year='1989').all(),
[MappedBooks(published_year=u'1989', n=1)])
def test_map_to_invalid_schema(self):
db = sqlsoup.SqlSoup(engine)
table = Table('users', db._metadata, Column('id', Integer))
assert_raises_message(exc.ArgumentError,
"'tablename' argument is required when "
"using 'schema'.",
db.map_to,
'users',
selectable=table,
schema='hoho')
def test_map_to_table_or_selectable(self):
db = sqlsoup.SqlSoup(engine)
table = Table('users', db._metadata,
Column('id', Integer, primary_key=True))
assert_raises_message(
exc.ArgumentError,
"'tablename' and 'selectable' arguments are mutually exclusive",
db.map_to,
'users',
tablename='users',
selectable=table)
def test_explicit_session(self):
Session = scoped_session(sessionmaker())
db = sqlsoup.SqlSoup(engine, session=Session)
try:
MappedUsers = db.users
sess = Session()
assert db.users._query.session is db.users.session is sess
row = db.users.insert(name='new name', email='new email')
assert row in sess
finally:
sess.rollback()
sess.close()
def test_whereclause(self):
db = sqlsoup.SqlSoup(engine)
MappedUsers = db.users
where = or_(db.users.name == 'Bhargan Basepair', db.users.email
== '*****@*****.**')
users = \
db.users.filter(where).order_by(desc(db.users.name)).all()
eq_(users, [MappedUsers(name=u'Joe Student',
email=u'*****@*****.**', password=u'student',
classname=None, admin=0),
MappedUsers(name=u'Bhargan Basepair',
email=u'*****@*****.**', password=u'basepair',
classname=None, admin=1)])
def daemon_loop(self, db_connection_url):
'''Main processing loop for Non-Tunneling Agent.
:param options: database information - in the event need to reconnect
'''
self.local_vlan_map = {}
old_local_bindings = {}
old_vif_ports = {}
db_connected = False
while True:
if not db_connected:
time.sleep(self.reconnect_interval)
db = sqlsoup.SqlSoup(db_connection_url)
db_connected = True
LOG.info("Connecting to database \"%s\" on %s" %
(db.engine.url.database, db.engine.url.host))
all_bindings = {}
try:
flavor_key = db.flavors.network_id
port_key = db.ports.network_id
query = db.session.query(db.ports)
joined = query.join((db.flavors, flavor_key == port_key))
where = db.flavors.flavor == 'openvswitch'
ports = joined.filter(where).all()
except Exception, e:
LOG.info("Unable to get port bindings! Exception: %s" % e)
db_connected = False
continue
for port in ports:
if self.target_v2_api:
all_bindings[port.id] = port
else:
all_bindings[port.interface_id] = port
vlan_bindings = {}
try:
flavor_key = db.flavors.network_id
vlan_key = db.vlan_bindings.network_id
query = db.session.query(db.vlan_bindings)
joined = query.join((db.flavors, flavor_key == vlan_key))
where = db.flavors.flavor == 'openvswitch'
vlan_binds = joined.filter(where).all()
except Exception, e:
LOG.info("Unable to get vlan bindings! Exception: %s" % e)
db_connected = False
continue
def test_raw_sql(self):
db = sqlsoup.SqlSoup(engine)
rp = db.execute('select name, email from users order by name')
eq_(rp.fetchall(), [('Bhargan Basepair', '*****@*****.**'
), ('Joe Student', '*****@*****.**')])
# test that execute() shares the same transactional context as
# the session
db.execute("update users set email='foo bar'")
eq_(db.execute('select distinct email from users').fetchall(),
[('foo bar', )])
db.rollback()
eq_(db.execute('select distinct email from users').fetchall(),
[(u'*****@*****.**', ), (u'*****@*****.**', )])
def test_crud(self):
# note we're testing autoflush here too...
db = sqlsoup.SqlSoup(engine)
MappedLoans = db.loans
user = db.users.filter_by(name='Bhargan Basepair').one()
book_id = db.books.filter_by(title='Regional Variation in Moss'
).first().id
loan_insert = db.loans.insert(book_id=book_id,
user_name=user.name)
loan = db.loans.filter_by(book_id=2,
user_name='Bhargan Basepair').one()
eq_(loan, loan_insert)
l2 = MappedLoans(book_id=2, user_name=u'Bhargan Basepair',
loan_date=loan.loan_date)
eq_(loan, l2)
db.expunge(l2)
db.delete(loan)
loan = db.loans.filter_by(book_id=2,
user_name='Bhargan Basepair').first()
assert loan is None
def daemon_loop(self, db_connection_url):
'''Main processing loop for Non-Tunneling Agent.
:param options: database information - in the event need to reconnect
'''
self.local_vlan_map = {}
old_local_bindings = {}
old_vif_ports = {}
db_connected = False
while True:
if not db_connected:
time.sleep(self.reconnect_interval)
db = sqlsoup.SqlSoup(db_connection_url)
db_connected = True
LOG.info("Connecting to database \"%s\" on %s" %
(db.engine.url.database, db.engine.url.host))
all_bindings = {}
try:
ports = db.ports.all()
except Exception, e:
LOG.info("Unable to get port bindings! Exception: %s" % e)
db_connected = False
continue
for port in ports:
if self.target_v2_api:
all_bindings[port.id] = port
else:
all_bindings[port.interface_id] = port
vlan_bindings = {}
try:
vlan_binds = db.vlan_bindings.all()
except Exception, e:
LOG.info("Unable to get vlan bindings! Exception: %s" % e)
db_connected = False
continue
def daemon_loop(self, db_connection_url):
'''Main processing loop for Tunneling Agent.
:param options: database information - in the event need to reconnect
'''
old_local_bindings = {}
old_vif_ports = {}
old_tunnel_ips = set()
db = sqlsoup.SqlSoup(db_connection_url)
LOG.info("Connecting to database \"%s\" on %s" %
(db.engine.url.database, db.engine.url.host))
while True:
try:
all_bindings = dict((p.interface_id, Port(p))
for p in db.ports.all())
all_bindings_vif_port_ids = set(all_bindings)
lsw_id_bindings = dict((bind.network_id, bind.vlan_id)
for bind in db.vlan_bindings.all())
tunnel_ips = set(x.ip_address for x in db.tunnel_ips.all())
self.manage_tunnels(tunnel_ips, old_tunnel_ips, db)
# Get bindings from OVS bridge.
vif_ports = self.int_br.get_vif_ports()
new_vif_ports = dict([(p.vif_id, p) for p in vif_ports])
new_vif_ports_ids = set(new_vif_ports.keys())
old_vif_ports_ids = set(old_vif_ports.keys())
dead_vif_ports_ids = (new_vif_ports_ids -
all_bindings_vif_port_ids)
dead_vif_ports = [new_vif_ports[p] for p in dead_vif_ports_ids]
disappeared_vif_ports_ids = (old_vif_ports_ids -
new_vif_ports_ids)
new_local_bindings_ids = (all_bindings_vif_port_ids.
intersection(new_vif_ports_ids))
new_local_bindings = dict([(p, all_bindings.get(p))
for p in new_vif_ports_ids])
new_bindings = set(
(p, old_local_bindings.get(p),
new_local_bindings.get(p)) for p in new_vif_ports_ids)
changed_bindings = set([b for b in new_bindings
if b[2] != b[1]])
LOG.debug('all_bindings: %s', all_bindings)
LOG.debug('lsw_id_bindings: %s', lsw_id_bindings)
LOG.debug('new_vif_ports_ids: %s', new_vif_ports_ids)
LOG.debug('dead_vif_ports_ids: %s', dead_vif_ports_ids)
LOG.debug('old_vif_ports_ids: %s', old_vif_ports_ids)
LOG.debug('new_local_bindings_ids: %s',
new_local_bindings_ids)
LOG.debug('new_local_bindings: %s', new_local_bindings)
LOG.debug('new_bindings: %s', new_bindings)
LOG.debug('changed_bindings: %s', changed_bindings)
# Take action.
for p in dead_vif_ports:
LOG.info("No quantum binding for port " + str(p)
+ "putting on dead vlan")
self.port_dead(p)
for b in changed_bindings:
port_id, old_port, new_port = b
p = new_vif_ports[port_id]
if old_port:
old_net_uuid = old_port.network_id
LOG.info("Removing binding to net-id = " +
old_net_uuid + " for " + str(p)
+ " added to dead vlan")
self.port_unbound(p, old_net_uuid)
all_bindings[p.vif_id].op_status = OP_STATUS_DOWN
if not new_port:
self.port_dead(p)
if new_port:
new_net_uuid = new_port.network_id
if new_net_uuid not in lsw_id_bindings:
LOG.warn("No ls-id binding found for net-id '%s'" %
new_net_uuid)
continue
lsw_id = lsw_id_bindings[new_net_uuid]
self.port_bound(p, new_net_uuid, lsw_id)
all_bindings[p.vif_id].op_status = OP_STATUS_UP
LOG.info("Port %s on net-id = %s bound to %s " % (
str(p), new_net_uuid,
str(self.local_vlan_map[new_net_uuid])))
for vif_id in disappeared_vif_ports_ids:
LOG.info("Port Disappeared: " + vif_id)
if vif_id in all_bindings:
all_bindings[vif_id].op_status = OP_STATUS_DOWN
old_port = old_local_bindings.get(vif_id)
if old_port:
self.port_unbound(old_vif_ports[vif_id],
old_port.network_id)
# commit any DB changes and expire
# data loaded from the database
db.commit()
# sleep and re-initialize state for next pass
time.sleep(self.polling_interval)
old_tunnel_ips = tunnel_ips
old_vif_ports = new_vif_ports
old_local_bindings = new_local_bindings
except:
LOG.exception("Main-loop Exception:")
self.rollback_until_success(db)
def test_connection(self):
db = sqlsoup.SqlSoup(engine)
conn = db.connection()
rp = conn.execute('select name, email from users order by name')
eq_(rp.fetchall(), [('Bhargan Basepair', '*****@*****.**'
), ('Joe Student', '*****@*****.**')])
def test_relate_m2o(self):
db = sqlsoup.SqlSoup(engine)
db.loans.relate('user', db.users)
u1 = db.users.filter(db.users.c.name == 'Joe Student').one()
eq_(db.loans.first().user, u1)
def test_bad_names(self):
db = sqlsoup.SqlSoup(engine)
# print db.bad_names.c.id
print db.bad_names.c.query
def test_entity(self):
db = sqlsoup.SqlSoup(engine)
tablename = 'loans'
eq_(db.entity(tablename), db.loans)
def test_entity_with_different_base(self):
class subclass(object):
pass
db = sqlsoup.SqlSoup(engine, base=subclass)
assert issubclass(db.entity('loans'), subclass)
def test_nosuchtable(self):
db = sqlsoup.SqlSoup(engine)
assert_raises(exc.NoSuchTableError, getattr, db, 'nosuchtable')
def test_no_pk(self):
db = sqlsoup.SqlSoup(engine)
assert_raises(sqlsoup.PKNotFoundError, getattr, db, 'nopk')
