def test_update(self):
p1 = self.create_person_one()
objectstore.flush()
objectstore.clear()
person = Person.select()[0]
person.gender = 'F'
objectstore.flush()
objectstore.clear()
self.assertEquals(person.row_version, 2)
person = Person.select()[0]
person.gender = 'M'
objectstore.flush()
objectstore.clear()
self.assertEquals(person.row_version, 3)
#TODO: check that a concurrent modification raises exception
p1 = Person.select()[0]
s1 = objectstore.session
s2 = create_session()
objectstore.context.current = s2
p2 = Person.select()[0]
p1.first_name = "jack"
p2.first_name = "ed"
objectstore.flush()
try:
objectstore.context.current = s1
objectstore.flush()
# Only dialects with a sane rowcount can detect the ConcurrentModificationError
if testbase.db.dialect.supports_sane_rowcount():
assert False
except exceptions.ConcurrentModificationError:
pass
def test_update(self):
p1 = self.create_person_one()
objectstore.flush()
objectstore.clear()
person = Person.select()[0]
person.gender = 'F'
objectstore.flush()
objectstore.clear()
self.assertEquals(person.row_version, 2)
person = Person.select()[0]
person.gender = 'M'
objectstore.flush()
objectstore.clear()
self.assertEquals(person.row_version, 3)
#TODO: check that a concurrent modification raises exception
p1 = Person.select()[0]
s1 = objectstore.session
s2 = create_session()
objectstore.context.current = s2
p2 = Person.select()[0]
p1.first_name = "jack"
p2.first_name = "ed"
objectstore.flush()
try:
objectstore.context.current = s1
objectstore.flush()
# Only dialects with a sane rowcount can detect the ConcurrentModificationError
if testbase.db.dialect.supports_sane_rowcount():
assert False
except exceptions.ConcurrentModificationError:
pass
def getCohIds(self):
"""
Returns the list of commands_on_host linked to this command
"""
session = sqlalchemy.create_session()
myCommandOnHosts = session.query(CommandsOnHost).filter(CommandsOnHost.fk_commands == self.getId())
session.close()
return myCommandOnHosts.all()
def getCohIds(self):
"""
Returns the list of commands_on_host linked to this command
"""
session = sqlalchemy.create_session()
myCommandOnHosts = session.query(CommandsOnHost).filter(CommandsOnHost.fk_commands == self.getId())
session.close()
return myCommandOnHosts.all()
def __init__(self, engine=None, session=None):
if session is None:
session = sqla.create_session()
self.session = session
self.engine = engine
self.userQuery = session.query(models.User)
self.nodeQuery = session.query(models.Node)
self.nbQuery = session.query(models.Notebook)
self.users = []
def __init__(self):
self._db = create_engine(os.getenv('DB_DRIVER'))
self._metadata = BoundMetaData(self.__db)
self.__user = mapper(
User, Table(os.getenv('USER_TABLE'), self._metadata,
autoload=True))
self.__event = mapper(
Event,
Table(os.getenv('EVENT_TABLE'), self._metadata, autoload=True))
self.__payment = mapper(
Payment,
Table(os.getenv('PAYMENT_TABLE'), self._metadata, autoload=True))
self._session = create_session()
def stopCommand(c_id):
"""
Stop a command, by stopping all its related commands_on_host.
@returns: the list of all related commands_on_host
@rtype: list
"""
session = sqlalchemy.create_session()
myCommand = session.query(Commands).get(c_id)
ret = []
for cmd in myCommand.getCohIds():
ret.append(cmd)
stopCommandOnHost(cmd.id)
session.close()
return ret
def stopCommand(c_id):
"""
Stop a command, by stopping all its related commands_on_host.
@returns: the list of all related commands_on_host
@rtype: list
"""
session = sqlalchemy.create_session()
myCommand = session.query(Commands).get(c_id)
ret = []
for cmd in myCommand.getCohIds():
ret.append(cmd)
stopCommandOnHost(cmd.id)
session.close()
return ret
def dumpDBtoXML(session=None, fname=None):
"""Build an XML String"""
if session is None:
session = sqla.create_session()
users = session.query(models.User).select()
s = "<XMLBackup>\n"
for u in users:
s += models.indent(u.xmlize(justme=False),2)
s += "</XMLBackup>\n"
if fname is not None:
f = open(fname, 'w')
f.write(s)
f.close()
# else:
return s
def _setUp(self, scriptfile="implicit_chaining_1.xml"):
self.job_script = file(self.database + "data/job_scripts/%s" % scriptfile).read()
self.job_schedule = "now"
self.job_input_uri_list = "<input><uri>/workspaces/1/hosts/resources/1/</uri>\n<uri>/workspaces/1/hosts/resources/2/</uri></input>"
self.job_xml = '%s%s\n<when>%s</when>\n%s\n</JobDefinition>' % (
'<?xml version="1.0"?>\n<JobDefinition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" href="/workspaces/1/jobs/234/">',
re.sub(r'^<\?[^\?]+\?>', '', self.job_script),
re.sub(r'^<\?[^\?]+\?>', '', self.job_schedule),
re.sub(r'^<\?[^\?]+\?>', '', self.job_input_uri_list),
)
self.script_runner = sr.ScriptRunner(indexer=False, mbus=self.mbus, testing=True)
self.script_runner.indexer = testindexer.ACTestIndexer()
self.session = sa.create_session()
self.t_job = models.Job("ScriptRunner TestJob #1", schedule=self.job_schedule, input=self.job_input_uri_list, script=self.job_script, workspace_id=1)
self.session.save(self.t_job)
self.session.update(self.t_job)
self.t_res = models.ResultSet(name="%s Results Container @ %s" % (self.t_job.name, mir_datetime.strISO_now()), job=self.t_job, workspace_id=self.t_job.workspace_id)
self.session.save(self.t_res)
self.session.update(self.t_res)
self.t_job.results.append(self.t_res)
self.t_res.status = models.Status("Status for ResultSet %s" % self.t_res.id, activity='Starting', state='pending', status=None, id=self.t_res.id)
self.session.flush()
self.session.update(self.t_job)
self.session.save(self.t_job)
self.session.flush()
self.session.clear()
job_rec = {
'job_obj': self.t_job,
'result': self.t_res,
'job_identity': self.t_job.href,
'job_script': self.t_job.script,
'job_url': str(identity.identity_from_string(self.t_job.href)),
'script_dom': minidom.parseString(self.job_script),
'workspace_id': 1,
'input': self.t_job.input,
'job_elem': minidom.parseString('<?xml version="1.0" encoding="utf-8"?>%s' % self.t_job.dump_job_manifest()),
'executionMetaData': minidom.parseString('<?xml version="1.0" encoding="utf-8"?>%s' % self.t_res.dump_execution_manifest()),
}
self.job_rec = job_rec
def make_session(uri=None, echo=None, session_kwargs=None, **kwargs):
"""Returns a SQLAlchemy session for the specified database uri from
the the engine cache (returned from ``get_engines``)``. Uses the
configuration values from ``get_engine_conf`` for uri and echo when
None are specified.
``session_kwargs`` are passed to SQLAlchemy's ``create_session``
function as keyword arguments.
If the uri's engine does not exist, it will be created and added to
the engine cache.
"""
if session_kwargs is None:
session_kwargs = {}
engine = create_engine(uri, echo=echo, **kwargs)
log.debug("Created engine for session context")
return sqlalchemy.create_session(bind_to=engine, **session_kwargs)
def make_session(uri=None, echo=None, session_kwargs=None, **kwargs):
"""Returns a SQLAlchemy session for the specified database uri from
the the engine cache (returned from ``get_engines``)``. Uses the
configuration values from ``get_engine_conf`` for uri and echo when
None are specified.
``session_kwargs`` are passed to SQLAlchemy's ``create_session``
function as keyword arguments.
If the uri's engine does not exist, it will be created and added to
the engine cache.
"""
if session_kwargs is None:
session_kwargs = {}
engine = create_engine(uri, echo=echo, **kwargs)
log.debug("Created engine for session context")
return sqlalchemy.create_session(bind_to=engine, **session_kwargs)
def __init__(self, object_path, options, connection=None, **kw):
from sqlalchemy import BoundMetaData, create_engine
from sqlalchemy.ext.sessioncontext import SessionContext
self.connection = connection
super(SQLAlchemyHandler, self).__init__(object_path, options, **kw)
if not self.connection:
if self.options.dsn:
self.meta = BoundMetaData(self.options.dsn)
else:
raise MisconfiguredHandler("--dsn option is required by %s" %
self.__class__)
self.connection = self.meta.engine.connect()
self.session_context = SessionContext(
lambda: sqlalchemy.create_session(bind_to=self.connection))
self.env = TableEnv(*[self.obj.__module__] + self.options.env)
def mergeDB(*dburis):
"""merge databases through XML
*this should go in dbutil, but cannot until it can be done without xml*
"""
dblist = []
for name in dburis:
if '://' not in name:# guess it is just a filename, use sqlite
name = 'sqlite:///'+name
dblist.append(name)
targetURI = dblist.pop(0)
if targetURI == 'sqlite://':
dbutil.initDB(targetURI)
while dblist:
engine = sqla.create_engine(dblist.pop(0))
models.metadata.connect(engine)
s = dumpDBtoXML()
session = sqla.create_session()
engine = sqla.create_engine(targetURI)
models.metadata.connect(engine)
loadDBfromXML(session, s)
def __init__(self):
self.metadata = sa.BoundMetaData('sqlite:///cwc3.db')
self.session = sa.create_session()
self.InitTables()
def flush(self):
""" Handle SQL flushing """
session = sqlalchemy.create_session()
session.add(self)
session.flush()
session.close()
def flush(self):
""" Handle SQL flushing """
session = sqlalchemy.create_session()
session.add(self)
session.flush()
session.close()
SQLAColumn('category_id', Integer, ForeignKey('category.id')),
SQLAColumn('date', Date),
)
class Task(object):
"""A task"""
mapper(Task, task_table, properties=dict(
category = relation(Category, backref='tasks'),
))
engine = create_engine('sqlite:///')
meta.connect(engine)
meta.create_all()
session = create_session(bind_to=engine)
for category in ['Work',
'Home',
'School']:
c = Category()
c.name=category
session.save(c)
session.flush()
work = session.query(Category).select_by(name='Work')[0]
home = session.query(Category).select_by(name='Home')[0]
school = session.query(Category).select_by(name='School')[0]
def __init__(self):
self.metadata = sa.BoundMetaData('sqlite:///cwc3.db')
self.session = sa.create_session()
self.InitTables()
def create_session():
"Creates a session with the appropriate engine"
return sqlalchemy.create_session(bind_to=get_engine())
def _setUp(self, scriptfile="implicit_chaining_1.xml"):
self.job_script = file(self.database +
"data/job_scripts/%s" % scriptfile).read()
self.job_schedule = "now"
self.job_input_uri_list = "<input><uri>/workspaces/1/hosts/resources/1/</uri>\n<uri>/workspaces/1/hosts/resources/2/</uri></input>"
self.job_xml = '%s%s\n<when>%s</when>\n%s\n</JobDefinition>' % (
'<?xml version="1.0"?>\n<JobDefinition xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" href="/workspaces/1/jobs/234/">',
re.sub(r'^<\?[^\?]+\?>', '', self.job_script),
re.sub(r'^<\?[^\?]+\?>', '', self.job_schedule),
re.sub(r'^<\?[^\?]+\?>', '', self.job_input_uri_list),
)
self.script_runner = sr.ScriptRunner(indexer=False,
mbus=self.mbus,
testing=True)
self.script_runner.indexer = testindexer.ACTestIndexer()
self.session = sa.create_session()
self.t_job = models.Job("ScriptRunner TestJob #1",
schedule=self.job_schedule,
input=self.job_input_uri_list,
script=self.job_script,
workspace_id=1)
self.session.save(self.t_job)
self.session.update(self.t_job)
self.t_res = models.ResultSet(
name="%s Results Container @ %s" %
(self.t_job.name, mir_datetime.strISO_now()),
job=self.t_job,
workspace_id=self.t_job.workspace_id)
self.session.save(self.t_res)
self.session.update(self.t_res)
self.t_job.results.append(self.t_res)
self.t_res.status = models.Status("Status for ResultSet %s" %
self.t_res.id,
activity='Starting',
state='pending',
status=None,
id=self.t_res.id)
self.session.flush()
self.session.update(self.t_job)
self.session.save(self.t_job)
self.session.flush()
self.session.clear()
job_rec = {
'job_obj':
self.t_job,
'result':
self.t_res,
'job_identity':
self.t_job.href,
'job_script':
self.t_job.script,
'job_url':
str(identity.identity_from_string(self.t_job.href)),
'script_dom':
minidom.parseString(self.job_script),
'workspace_id':
1,
'input':
self.t_job.input,
'job_elem':
minidom.parseString('<?xml version="1.0" encoding="utf-8"?>%s' %
self.t_job.dump_job_manifest()),
'executionMetaData':
minidom.parseString('<?xml version="1.0" encoding="utf-8"?>%s' %
self.t_res.dump_execution_manifest()),
}
self.job_rec = job_rec
"""sqlalchemy table and ORM definitions for Agora."""
from sqlalchemy import create_engine, create_session, BoundMetaData, \
Table, mapper, relation, func
DATABASE_URL = 'postgres://agora@localhost/agora'
engine = create_engine(DATABASE_URL)
session = create_session(bind_to=engine)
metadata = BoundMetaData(engine)
_entity = Table('entity', metadata, autoload=True)
_player = Table('player', metadata, autoload=True)
class DbObject(object):
def __repr__(self):
return '(%s: %s)' % (type(self),
', '.join('%s=%s' % (x, getattr(self, x)) \
for x in self.c.keys()))
class Entity(DbObject):
pass
class Player(DbObject):
def get_name(self):
return self.entity.name
def set_name(self, name):
self.entity.name = name
name = property(get_name, set_name)
def get_short(self):
