def __init__(self, backend, computer, user):
"""
Construct an SqlaAuthInfo
:param computer: a Computer instance
:param user: a User instance
:return: an AuthInfo object associated with the given computer and user
"""
super(SqlaAuthInfo, self).__init__(backend)
type_check(user, users.SqlaUser)
self._dbauthinfo = utils.ModelWrapper(DbAuthInfo(dbcomputer=computer.dbcomputer, aiidauser=user.dbuser))
def __init__(self, **kwargs):
super(Node, self).__init__()
self._temp_folder = None
dbnode = kwargs.pop('dbnode', None)
# Set the internal parameters
# Can be redefined in the subclasses
self._init_internal_params()
if dbnode is not None:
type_check(dbnode, DbNode)
if dbnode.id is None:
raise ValueError("If cannot load an aiida.orm.Node instance "
"from an unsaved DbNode object.")
if kwargs:
raise ValueError("If you pass a dbnode, you cannot pass any "
"further parameter")
# If I am loading, I cannot modify it
self._to_be_stored = False
self._dbnode = dbnode
# If this is changed, fix also the importer
self._repo_folder = RepositoryFolder(section=self._section_name,
uuid=self.uuid)
else:
user = self._backend.users.get_automatic_user()
if user is None:
raise RuntimeError("Could not find a default user")
self._dbnode = DbNode(user=user.dbuser,
uuid=get_new_uuid(),
type=self._plugin_type_string)
self._to_be_stored = True
# As creating the temp folder may require some time on slow
# filesystems, we defer its creation
self._temp_folder = None
# Used only before the first save
self._attrs_cache = {}
# If this is changed, fix also the importer
self._repo_folder = RepositoryFolder(section=self._section_name,
uuid=self.uuid)
# Automatically set all *other* attributes, if possible, otherwise
# stop
self._set_with_defaults(**kwargs)
def from_dbmodel(cls, dbmodel, backend):
"""
Create a DjangoUser from a dbmodel instance
:param backend: The backend
:type backend: :class:`DjangoUserCollection`
:param dbmodel: The dbmodel instance
:type dbmodel: :class:`aiida.backends.djsite.db.models.DbUser`
:return: A DjangoUser instance
:rtype: :class:`DjangoUser`
"""
type_check(dbmodel, DbUser)
user = cls.__new__(cls)
super(DjangoUser, user).__init__(backend)
user._dbuser = utils.ModelWrapper(dbmodel)
return user
def __init__(self, **kwargs):
from aiida.backends.djsite.db.models import DbGroup
from aiida.orm.backend import construct_backend
self._backend = construct_backend()
dbgroup = kwargs.pop('dbgroup', None)
if dbgroup is not None:
if kwargs:
raise ValueError(
"If you pass a dbgroups, you cannot pass any further parameter"
)
if isinstance(dbgroup, (int, long)):
try:
dbgroup = DbGroup.objects.get(pk=dbgroup)
except ObjectDoesNotExist:
raise NotExistent(
"Group with pk={} does not exist".format(dbgroup))
type_check(dbgroup, DbGroup)
self._dbgroup = utils.ModelWrapper(dbgroup)
else:
name = kwargs.pop('name', None)
if name is None:
raise ValueError("You have to specify a group name")
group_type = kwargs.pop('type_string',
"") # By default, a user group
# Get the user and extract dbuser instance
user = kwargs.pop('user', self._backend.users.get_automatic_user())
description = kwargs.pop('description', "")
self._dbgroup = utils.ModelWrapper(
DbGroup(name=name,
description=description,
user=user.dbuser,
type=group_type))
if kwargs:
raise ValueError("Too many parameters passed to Group, the "
"unknown parameters are: {}".format(", ".join(
kwargs.keys())))
def user(self, new_user):
type_check(new_user, users.SqlaUser)
self._dbgroup.user = new_user.dbuser
def from_dbmodel(cls, dbmodel, backend):
type_check(dbmodel, DbAuthInfo)
authinfo = cls.__new__(cls)
super(DjangoAuthInfo, authinfo).__init__(backend)
authinfo._dbauthinfo = utils.ModelWrapper(dbmodel)
return authinfo
def _add_dblink_from(self,
src,
label=None,
link_type=LinkType.UNSPECIFIED):
from aiida.backends.sqlalchemy import get_scoped_session
from aiida.orm.querybuilder import QueryBuilder
session = get_scoped_session()
type_check(src, Node)
if self.uuid == src.uuid:
raise ValueError("Cannot link to itself")
if not self.is_stored:
raise ModificationNotAllowed(
"Cannot call the internal _add_dblink_from if the "
"destination node is not stored")
if not src.is_stored:
raise ModificationNotAllowed(
"Cannot call the internal _add_dblink_from if the "
"source node is not stored")
# Check for cycles. This works if the transitive closure is enabled; if
# it isn't, this test will never fail, but then having a circular link
# is not meaningful but does not pose a huge threat
#
# I am linking src->self; a loop would be created if a DbPath exists
# already in the TC table from self to src
if link_type is LinkType.CREATE or link_type is LinkType.INPUT:
if QueryBuilder().append(
Node, filters={
'id': self.pk
}, tag='parent').append(
Node,
filters={
'id': src.pk
},
tag='child',
descendant_of='parent').count() > 0:
raise ValueError(
"The link you are attempting to create would generate a loop"
)
if label is None:
autolabel_idx = 1
existing_from_autolabels = session.query(DbLink.label).filter(
DbLink.output_id == self._dbnode.id,
DbLink.label.like("link%"))
while "link_{}".format(autolabel_idx) in existing_from_autolabels:
autolabel_idx += 1
safety_counter = 0
while True:
safety_counter += 1
if safety_counter > 100:
# Well, if you have more than 100 concurrent addings
# to the same node, you are clearly doing something wrong...
raise InternalError(
"Hey! We found more than 100 concurrent"
" adds of links "
"to the same nodes! Are you really doing that??")
try:
self._do_create_link(src, "link_{}".format(autolabel_idx),
link_type)
break
except UniquenessError:
# Retry loop until you find a new loop
autolabel_idx += 1
else:
self._do_create_link(src, label, link_type)
def set_user(self, user):
type_check(user, users.SqlaUser)
self._dbnode.user = user.dbuser
def from_dbmodel(cls, dbmodel, backend):
type_check(dbmodel, DbUser)
user = cls.__new__(cls)
super(SqlaUser, user).__init__(backend)
user._dbuser = utils.ModelWrapper(dbmodel)
return user
