def __init__(self,
url,
table_name="store",
idfactory=None,
extra_fields=None,
create=True,
**extra_args):
"""
Open a connection to the storage database identified by `url`.
DB backend (MySQL, psql, sqlite3) is chosen based on the
`url.scheme` value.
"""
super(SqlStore, self).__init__(url)
# init static public args
if not idfactory:
self.idfactory = IdFactory(id_class=IntId)
else:
self.idfactory = idfactory
self.table_name = table_name
# save ctor args for lazy-initialization
self._init_extra_fields = (extra_fields
if extra_fields is not None else {})
self._init_create = create
# create slots for lazy-init'ed attrs
self._real_engine = None
self._real_extra_fields = None
self._real_tables = None
def test_new_item(self):
idfactory = IdFactory()
ids = []
dummy = DummyObject()
for i in range(10):
ids.append(idfactory.new(dummy))
assert len(ids) == len(set(ids))
# reserve is tested only in order to check if we get an error calling
# it...
idfactory.reserve(5)
def __init__(self,
directory=gc3libs.Default.JOBS_DIR,
idfactory=IdFactory(),
protocol=DEFAULT_PROTOCOL,
**extra_args):
if isinstance(directory, gc3libs.url.Url):
directory = directory.path
self._directory = directory
self.idfactory = idfactory
self._protocol = protocol
def __init__(self,
directory=gc3libs.Default.JOBS_DIR,
idfactory=IdFactory(),
protocol=DEFAULT_PROTOCOL,
**extra_args):
if isinstance(directory, Url):
super(FilesystemStore, self).__init__(directory)
directory = directory.path
else:
super(FilesystemStore, self).__init__(
Url(scheme='file', path=os.path.abspath(directory)))
self._directory = directory
self.idfactory = idfactory
self._protocol = protocol
def __init__(self,
url,
table_name=None,
idfactory=None,
extra_fields=None,
create=True,
**extra_args):
"""
Open a connection to the storage database identified by `url`.
DB backend (MySQL, psql, sqlite3) is chosen based on the
`url.scheme` value.
"""
super(SqlStore, self).__init__(url)
if self.url.fragment:
kv = parse_qs(self.url.fragment)
else:
kv = {}
# init static public args
if not idfactory:
self.idfactory = IdFactory(id_class=IntId)
else:
self.idfactory = idfactory
url_table_names = kv.get('table')
if url_table_names:
url_table_name = url_table_names[-1] # last wins
else:
url_table_name = ''
if table_name is None:
self.table_name = url_table_name or "store"
else:
if table_name != url_table_name:
gc3libs.log.debug(
"DB table name given in store URL fragment,"
" but overriden by `table` argument to SqlStore()")
self.table_name = table_name
# save ctor args for lazy-initialization
self._init_extra_fields = (extra_fields
if extra_fields is not None else {})
self._init_create = create
# create slots for lazy-init'ed attrs
self._real_engine = None
self._real_extra_fields = None
self._real_tables = None
def __init__(self,
url,
table_name="store",
idfactory=None,
extra_fields={},
create=True,
**extra_args):
"""
Open a connection to the storage database identified by
url. It will use the correct backend (MySQL, psql, sqlite3)
based on the url.scheme value
"""
self._engine = sqla.create_engine(str(url))
self.table_name = table_name
self.__meta = sqla.MetaData(bind=self._engine)
# create schema
table = sqla.Table(
self.table_name, self.__meta,
sqla.Column('id', sqla.Integer(),
primary_key=True, nullable=False),
sqla.Column('data', sqla.LargeBinary()),
sqla.Column('state', sqla.String(length=128)))
# create internal rep of table
self.extra_fields = dict()
for col, func in extra_fields.iteritems():
assert isinstance(col, sqla.Column)
table.append_column(col.copy())
self.extra_fields[col.name] = func
current_metadata = sqla.MetaData(bind=self._engine)
current_metadata.reflect()
# check if the db exists and already has a 'store' table
if create and self.table_name not in current_metadata.tables:
self.__meta.create_all()
self.t_store = self.__meta.tables[self.table_name]
self.idfactory = idfactory
if not idfactory:
self.idfactory = IdFactory(id_class=IntId)
def test_custom_next_id(self):
class next_id(object):
def __init__(self):
self.curid = -1
def __call__(self):
self.curid += 1
return self.curid
idfactory = IdFactory(next_id_fn=next_id())
ids = []
dummy = DummyObject()
for i in range(10):
ids.append(idfactory.new(dummy))
assert len(ids) == len(set(ids))
for i in range(len(ids)):
assert ids[i] == "DummyObject.%d" % i
def test_store_ctor_with_extra_arguments(cls, tmpdir):
"""Test if `Store`:class: classess accept extra keyword arguments
without complaining.
This test will ensure that any `Store` class can be called with
arguments which are valid only on other `Store` classes.
"""
args = {
'url': 'sqlite:///%s/test.sqlite' % os.path.abspath(str(tmpdir)),
'table_name': 'store',
'create': True,
'directory': str(tmpdir),
'idfactory': IdFactory(),
'protocol': DEFAULT_PROTOCOL,
'extra_fields': {
sqlalchemy.Column('extra', sqlalchemy.TEXT()): lambda x: "test"
},
}
cls(**args)
