1 # copyright 2003-2014 LOGILAB S.A. (Paris, FRANCE), all rights reserved.

     2 # contact http://www.logilab.fr/ -- mailto:contact@logilab.fr

     3 #

     4 # This file is part of CubicWeb.

     5 #

     6 # CubicWeb is free software: you can redistribute it and/or modify it under the

     7 # terms of the GNU Lesser General Public License as published by the Free

     8 # Software Foundation, either version 2.1 of the License, or (at your option)

     9 # any later version.

    10 #

    11 # CubicWeb is distributed in the hope that it will be useful, but WITHOUT

    12 # ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS

    13 # FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public License for more

    14 # details.

    15 #

    16 # You should have received a copy of the GNU Lesser General Public License along

    17 # with CubicWeb.  If not, see <http://www.gnu.org/licenses/>.

    18 """a class implementing basic actions used in migration scripts.

    19 

    20 The following schema actions are supported for now:

    21 * add/drop/rename attribute

    22 * add/drop entity/relation type

    23 * rename entity type

    24 

    25 The following data actions are supported for now:

    26 * add an entity

    27 * execute raw RQL queries

    28 """

    29 from __future__ import print_function

    30 

    31 __docformat__ = "restructuredtext en"

    32 

    33 import sys

    34 import os

    35 import tarfile

    36 import tempfile

    37 import shutil

    38 import os.path as osp

    39 from datetime import datetime

    40 from glob import glob

    41 from copy import copy

    42 from warnings import warn

    43 from contextlib import contextmanager

    44 

    45 from six import PY2, text_type

    46 

    47 from logilab.common.deprecation import deprecated

    48 from logilab.common.decorators import cached, clear_cache

    49 

    50 from yams.buildobjs import EntityType

    51 from yams.constraints import SizeConstraint

    52 from yams.schema import RelationDefinitionSchema

    53 

    54 from cubicweb import CW_SOFTWARE_ROOT, AuthenticationError, ExecutionError

    55 from cubicweb.predicates import is_instance

    56 from cubicweb.schema import (ETYPE_NAME_MAP, META_RTYPES, VIRTUAL_RTYPES,

    57                              PURE_VIRTUAL_RTYPES,

    58                              CubicWebRelationSchema, order_eschemas)

    59 from cubicweb.cwvreg import CW_EVENT_MANAGER

    60 from cubicweb import repoapi

    61 from cubicweb.migration import MigrationHelper, yes

    62 from cubicweb.server import hook, schemaserial as ss

    63 from cubicweb.server.schema2sql import eschema2sql, rschema2sql, unique_index_name, sql_type

    64 from cubicweb.server.utils import manager_userpasswd

    65 from cubicweb.server.sqlutils import sqlexec, SQL_PREFIX

    66 

    67 

    68 class ClearGroupMap(hook.Hook):

    69     __regid__ = 'cw.migration.clear_group_mapping'

    70     __select__ = hook.Hook.__select__ & is_instance('CWGroup')

    71     events = ('after_add_entity', 'after_update_entity',)

    72     def __call__(self):

    73         clear_cache(self.mih, 'group_mapping')

    74         self.mih._synchronized.clear()

    75 

    76     @classmethod

    77     def mih_register(cls, repo):

    78         # may be already registered in tests (e.g. unittest_migractions at

    79         # least)

    80         if not cls.__regid__ in repo.vreg['after_add_entity_hooks']:

    81             repo.vreg.register(ClearGroupMap)

    82 

    83 

    84 class ServerMigrationHelper(MigrationHelper):

    85     """specific migration helper for server side migration scripts,

    86     providing actions related to schema/data migration

    87     """

    88 

    89     def __init__(self, config, schema, interactive=True,

    90                  repo=None, cnx=None, verbosity=1, connect=True):

    91         MigrationHelper.__init__(self, config, interactive, verbosity)

    92         if not interactive:

    93             assert cnx

    94             assert repo

    95         if cnx is not None:

    96             assert repo

    97             self.cnx = cnx

    98             self.repo = repo

    99             self.session = cnx.session

   100         elif connect:

   101             self.repo = config.repository()

   102             self.set_cnx()

   103         else:

   104             self.session = None

   105         # no config on shell to a remote instance

   106         if config is not None and (cnx or connect):

   107             repo = self.repo

   108             # register a hook to clear our group_mapping cache and the

   109             # self._synchronized set when some group is added or updated

   110             ClearGroupMap.mih = self

   111             ClearGroupMap.mih_register(repo)

   112             CW_EVENT_MANAGER.bind('after-registry-reload',

   113                                   ClearGroupMap.mih_register, repo)

   114             # notify we're starting maintenance (called instead of server_start

   115             # which is called on regular start

   116             repo.hm.call_hooks('server_maintenance', repo=repo)

   117         if not schema and not config.quick_start:

   118             insert_lperms = self.repo.get_versions()['cubicweb'] < (3, 14, 0) and 'localperms' in config.available_cubes()

   119             if insert_lperms:

   120                 cubes = config._cubes

   121                 config._cubes += ('localperms',)

   122             try:

   123                 schema = config.load_schema(expand_cubes=True)

   124             finally:

   125                 if insert_lperms:

   126                     config._cubes = cubes

   127         self.fs_schema = schema

   128         self._synchronized = set()

   129 

   130     # overriden from base MigrationHelper ######################################

   131 

   132     def set_cnx(self):

   133         try:

   134             login = self.repo.config.default_admin_config['login']

   135             pwd = self.repo.config.default_admin_config['password']

   136         except KeyError:

   137             login, pwd = manager_userpasswd()

   138         while True:

   139             try:

   140                 self.cnx = repoapi.connect(self.repo, login, password=pwd)

   141                 if not 'managers' in self.cnx.user.groups:

   142                     print('migration need an account in the managers group')

   143                 else:

   144                     break

   145             except AuthenticationError:

   146                 print('wrong user/password')

   147             except (KeyboardInterrupt, EOFError):

   148                 print('aborting...')

   149                 sys.exit(0)

   150             try:

   151                 login, pwd = manager_userpasswd()

   152             except (KeyboardInterrupt, EOFError):

   153                 print('aborting...')

   154                 sys.exit(0)

   155         self.session = self.repo._get_session(self.cnx.sessionid)

   156 

   157     def cube_upgraded(self, cube, version):

   158         self.cmd_set_property('system.version.%s' % cube.lower(),

   159                               text_type(version))

   160         self.commit()

   161 

   162     def shutdown(self):

   163         if self.repo is not None:

   164             self.repo.shutdown()

   165 

   166     def migrate(self, vcconf, toupgrade, options):

   167         if not options.fs_only:

   168             if options.backup_db is None:

   169                 self.backup_database()

   170             elif options.backup_db:

   171                 self.backup_database(askconfirm=False)

   172         # disable notification during migration

   173         with self.cnx.allow_all_hooks_but('notification'):

   174             super(ServerMigrationHelper, self).migrate(vcconf, toupgrade, options)

   175 

   176     def cmd_process_script(self, migrscript, funcname=None, *args, **kwargs):

   177         try:

   178             return super(ServerMigrationHelper, self).cmd_process_script(

   179                   migrscript, funcname, *args, **kwargs)

   180         except ExecutionError as err:

   181             sys.stderr.write("-> %s\n" % err)

   182         except BaseException:

   183             self.rollback()

   184             raise

   185 

   186     # Adjust docstring

   187     cmd_process_script.__doc__ = MigrationHelper.cmd_process_script.__doc__

   188 

   189     # server specific migration methods ########################################

   190 

   191     def backup_database(self, backupfile=None, askconfirm=True, format='native'):

   192         config = self.config

   193         repo = self.repo

   194         # paths

   195         timestamp = datetime.now().strftime('%Y-%m-%d_%H-%M-%S')

   196         instbkdir = osp.join(config.appdatahome, 'backup')

   197         if not osp.exists(instbkdir):

   198             os.makedirs(instbkdir)

   199         backupfile = backupfile or osp.join(instbkdir, '%s-%s.tar.gz'

   200                                             % (config.appid, timestamp))

   201         # check backup has to be done

   202         if osp.exists(backupfile) and not \

   203                 self.confirm('Backup file %s exists, overwrite it?' % backupfile):

   204             print('-> no backup done.')

   205             return

   206         elif askconfirm and not self.confirm('Backup %s database?' % config.appid):

   207             print('-> no backup done.')

   208             return

   209         open(backupfile,'w').close() # kinda lock

   210         os.chmod(backupfile, 0o600)

   211         # backup

   212         source = repo.system_source

   213         tmpdir = tempfile.mkdtemp()

   214         try:

   215             failed = False

   216             try:

   217                 source.backup(osp.join(tmpdir, source.uri), self.confirm, format=format)

   218             except Exception as ex:

   219                 print('-> error trying to backup %s [%s]' % (source.uri, ex))

   220                 if not self.confirm('Continue anyway?', default='n'):

   221                     raise SystemExit(1)

   222                 else:

   223                     failed = True

   224             with open(osp.join(tmpdir, 'format.txt'), 'w') as format_file:

   225                 format_file.write('%s\n' % format)

   226             with open(osp.join(tmpdir, 'versions.txt'), 'w') as version_file:

   227                 versions = repo.get_versions()

   228                 for cube, version in versions.items():

   229                     version_file.write('%s %s\n' % (cube, version))

   230             if not failed:

   231                 bkup = tarfile.open(backupfile, 'w|gz')

   232                 for filename in os.listdir(tmpdir):

   233                     bkup.add(osp.join(tmpdir, filename), filename)

   234                 bkup.close()

   235                 # call hooks

   236                 repo.hm.call_hooks('server_backup', repo=repo, timestamp=timestamp)

   237                 # done

   238                 print('-> backup file',  backupfile)

   239         finally:

   240             shutil.rmtree(tmpdir)

   241 

   242     def restore_database(self, backupfile, drop=True, askconfirm=True, format='native'):

   243         # check

   244         if not osp.exists(backupfile):

   245             raise ExecutionError("Backup file %s doesn't exist" % backupfile)

   246         if askconfirm and not self.confirm('Restore %s database from %s ?'

   247                                            % (self.config.appid, backupfile)):

   248             return

   249         # unpack backup

   250         tmpdir = tempfile.mkdtemp()

   251         try:

   252             bkup = tarfile.open(backupfile, 'r|gz')

   253         except tarfile.ReadError:

   254             # assume restoring old backup

   255             shutil.copy(backupfile, osp.join(tmpdir, 'system'))

   256         else:

   257             for name in bkup.getnames():

   258                 if name[0] in '/.':

   259                     raise ExecutionError('Security check failed, path starts with "/" or "."')

   260             bkup.close() # XXX seek error if not close+open !?!

   261             bkup = tarfile.open(backupfile, 'r|gz')

   262             bkup.extractall(path=tmpdir)

   263             bkup.close()

   264         if osp.isfile(osp.join(tmpdir, 'format.txt')):

   265             with open(osp.join(tmpdir, 'format.txt')) as format_file:

   266                 written_format = format_file.readline().strip()

   267                 if written_format in ('portable', 'native'):

   268                     format = written_format

   269         self.config.init_cnxset_pool = False

   270         repo = self.repo = self.config.repository()

   271         source = repo.system_source

   272         try:

   273             source.restore(osp.join(tmpdir, source.uri), self.confirm, drop, format)

   274         except Exception as exc:

   275             print('-> error trying to restore %s [%s]' % (source.uri, exc))

   276             if not self.confirm('Continue anyway?', default='n'):

   277                 raise SystemExit(1)

   278         shutil.rmtree(tmpdir)

   279         # call hooks

   280         repo.init_cnxset_pool()

   281         repo.hm.call_hooks('server_restore', repo=repo, timestamp=backupfile)

   282         print('-> database restored.')

   283 

   284     def commit(self):

   285         self.cnx.commit()

   286 

   287     def rollback(self):

   288         self.cnx.rollback()

   289 

   290     def rqlexecall(self, rqliter, ask_confirm=False):

   291         for rql, kwargs in rqliter:

   292             self.rqlexec(rql, kwargs, ask_confirm=ask_confirm)

   293 

   294     @cached

   295     def _create_context(self):

   296         """return a dictionary to use as migration script execution context"""

   297         context = super(ServerMigrationHelper, self)._create_context()

   298         context.update({'commit': self.checkpoint,

   299                         'rollback': self.rollback,

   300                         'sql': self.sqlexec,

   301                         'rql': self.rqlexec,

   302                         'rqliter': self.rqliter,

   303                         'schema': self.repo.get_schema(),

   304                         'cnx': self.cnx,

   305                         'fsschema': self.fs_schema,

   306                         'session' : self.cnx,

   307                         'repo' : self.repo,

   308                         })

   309         return context

   310 

   311     @cached

   312     def group_mapping(self):

   313         """cached group mapping"""

   314         return ss.group_mapping(self.cnx)

   315 

   316     def cstrtype_mapping(self):

   317         """cached constraint types mapping"""

   318         return ss.cstrtype_mapping(self.cnx)

   319 

   320     def cmd_exec_event_script(self, event, cube=None, funcname=None,

   321                               *args, **kwargs):

   322         """execute a cube event scripts  `migration/<event>.py` where event

   323         is one of 'precreate', 'postcreate', 'preremove' and 'postremove'.

   324         """

   325         assert event in ('precreate', 'postcreate', 'preremove', 'postremove')

   326         if cube:

   327             cubepath = self.config.cube_dir(cube)

   328             apc = osp.join(cubepath, 'migration', '%s.py' % event)

   329         elif kwargs.pop('apphome', False):

   330             apc = osp.join(self.config.apphome, 'migration', '%s.py' % event)

   331         else:

   332             apc = osp.join(self.config.migration_scripts_dir(), '%s.py' % event)

   333         if osp.exists(apc):

   334             if self.config.free_wheel:

   335                 self.cmd_deactivate_verification_hooks()

   336             self.info('executing %s', apc)

   337             confirm = self.confirm

   338             execscript_confirm = self.execscript_confirm

   339             self.confirm = yes

   340             self.execscript_confirm = yes

   341             try:

   342                 if event == 'postcreate':

   343                     with self.cnx.allow_all_hooks_but():

   344                         return self.cmd_process_script(apc, funcname, *args, **kwargs)

   345                 return self.cmd_process_script(apc, funcname, *args, **kwargs)

   346             finally:

   347                 self.confirm = confirm

   348                 self.execscript_confirm = execscript_confirm

   349                 if self.config.free_wheel:

   350                     self.cmd_reactivate_verification_hooks()

   351 

   352     def cmd_install_custom_sql_scripts(self, cube=None):

   353         """install a cube custom sql scripts `schema/*.<driver>.sql` where

   354         <driver> depends on the instance main database backend (eg 'postgres',

   355         'mysql'...)

   356         """

   357         driver = self.repo.system_source.dbdriver

   358         if cube is None:

   359             directory = osp.join(CW_SOFTWARE_ROOT, 'schemas')

   360         else:

   361             directory = osp.join(self.config.cube_dir(cube), 'schema')

   362         sql_scripts = glob(osp.join(directory, '*.%s.sql' % driver))

   363         for fpath in sql_scripts:

   364             print('-> installing', fpath)

   365             failed = sqlexec(open(fpath).read(), self.cnx.system_sql, False,

   366                              delimiter=';;')

   367             if failed:

   368                 print('-> ERROR, skipping', fpath)

   369 

   370     # schema synchronization internals ########################################

   371 

   372     def _synchronize_permissions(self, erschema, teid):

   373         """permission synchronization for an entity or relation type"""

   374         assert teid, erschema

   375         if 'update' in erschema.ACTIONS or erschema.final:

   376             # entity type

   377             exprtype = u'ERQLExpression'

   378         else:

   379             # relation type

   380             exprtype = u'RRQLExpression'

   381         gm = self.group_mapping()

   382         confirm = self.verbosity >= 2

   383         # * remove possibly deprecated permission (eg in the persistent schema

   384         #   but not in the new schema)

   385         # * synchronize existing expressions

   386         # * add new groups/expressions

   387         for action in erschema.ACTIONS:

   388             perm = '%s_permission' % action

   389             # handle groups

   390             newgroups = list(erschema.get_groups(action))

   391             for geid, gname in self.rqlexec('Any G, GN WHERE T %s G, G name GN, '

   392                                             'T eid %%(x)s' % perm, {'x': teid},

   393                                             ask_confirm=False):

   394                 if not gname in newgroups:

   395                     if not confirm or self.confirm('Remove %s permission of %s to %s?'

   396                                                    % (action, erschema, gname)):

   397                         self.rqlexec('DELETE T %s G WHERE G eid %%(x)s, T eid %s'

   398                                      % (perm, teid),

   399                                      {'x': geid}, ask_confirm=False)

   400                 else:

   401                     newgroups.remove(gname)

   402             for gname in newgroups:

   403                 if not confirm or self.confirm('Grant %s permission of %s to %s?'

   404                                                % (action, erschema, gname)):

   405                     try:

   406                         self.rqlexec('SET T %s G WHERE G eid %%(x)s, T eid %s'

   407                                      % (perm, teid),

   408                                      {'x': gm[gname]}, ask_confirm=False)

   409                     except KeyError:

   410                         self.error('can grant %s perm to unexistant group %s',

   411                                    action, gname)

   412             # handle rql expressions

   413             newexprs = dict((expr.expression, expr) for expr in erschema.get_rqlexprs(action))

   414             for expreid, expression in self.rqlexec('Any E, EX WHERE T %s E, E expression EX, '

   415                                                     'T eid %s' % (perm, teid),

   416                                                     ask_confirm=False):

   417                 if not expression in newexprs:

   418                     if not confirm or self.confirm('Remove %s expression for %s permission of %s?'

   419                                                    % (expression, action, erschema)):

   420                         # deleting the relation will delete the expression entity

   421                         self.rqlexec('DELETE T %s E WHERE E eid %%(x)s, T eid %s'

   422                                      % (perm, teid),

   423                                      {'x': expreid}, ask_confirm=False)

   424                 else:

   425                     newexprs.pop(expression)

   426             for expression in newexprs.values():

   427                 expr = expression.expression

   428                 if not confirm or self.confirm('Add %s expression for %s permission of %s?'

   429                                                % (expr, action, erschema)):

   430                     self.rqlexec('INSERT RQLExpression X: X exprtype %%(exprtype)s, '

   431                                  'X expression %%(expr)s, X mainvars %%(vars)s, T %s X '

   432                                  'WHERE T eid %%(x)s' % perm,

   433                                  {'expr': expr, 'exprtype': exprtype,

   434                                   'vars': u','.join(sorted(expression.mainvars)),

   435                                   'x': teid},

   436                                  ask_confirm=False)

   437 

   438     def _synchronize_rschema(self, rtype, syncrdefs=True,

   439                              syncperms=True, syncprops=True):

   440         """synchronize properties of the persistent relation schema against its

   441         current definition:

   442 

   443         * description

   444         * symmetric, meta

   445         * inlined

   446         * relation definitions if `syncrdefs`

   447         * permissions if `syncperms`

   448 

   449         physical schema changes should be handled by repository's schema hooks

   450         """

   451         rtype = str(rtype)

   452         if rtype in self._synchronized:

   453             return

   454         if syncrdefs and syncperms and syncprops:

   455             self._synchronized.add(rtype)

   456         rschema = self.fs_schema.rschema(rtype)

   457         reporschema = self.repo.schema.rschema(rtype)

   458         if syncprops:

   459             assert reporschema.eid, reporschema

   460             self.rqlexecall(ss.updaterschema2rql(rschema, reporschema.eid),

   461                             ask_confirm=self.verbosity>=2)

   462         if rschema.rule:

   463             if syncperms:

   464                 self._synchronize_permissions(rschema, reporschema.eid)

   465         elif syncrdefs:

   466             for subj, obj in rschema.rdefs:

   467                 if (subj, obj) not in reporschema.rdefs:

   468                     continue

   469                 if rschema in VIRTUAL_RTYPES:

   470                     continue

   471                 self._synchronize_rdef_schema(subj, rschema, obj,

   472                                               syncprops=syncprops,

   473                                               syncperms=syncperms)

   474 

   475     def _synchronize_eschema(self, etype, syncrdefs=True,

   476                              syncperms=True, syncprops=True):

   477         """synchronize properties of the persistent entity schema against

   478         its current definition:

   479 

   480         * description

   481         * internationalizable, fulltextindexed, indexed, meta

   482         * relations from/to this entity

   483         * __unique_together__

   484         * permissions if `syncperms`

   485         """

   486         etype = str(etype)

   487         if etype in self._synchronized:

   488             return

   489         if syncrdefs and syncperms and syncprops:

   490             self._synchronized.add(etype)

   491         repoeschema = self.repo.schema.eschema(etype)

   492         try:

   493             eschema = self.fs_schema.eschema(etype)

   494         except KeyError:

   495             return # XXX somewhat unexpected, no?...

   496         if syncprops:

   497             repospschema = repoeschema.specializes()

   498             espschema = eschema.specializes()

   499             if repospschema and not espschema:

   500                 self.rqlexec('DELETE X specializes Y WHERE X is CWEType, X name %(x)s',

   501                              {'x': str(repoeschema)}, ask_confirm=False)

   502             elif not repospschema and espschema:

   503                 self.rqlexec('SET X specializes Y WHERE X is CWEType, X name %(x)s, '

   504                              'Y is CWEType, Y name %(y)s',

   505                              {'x': str(repoeschema), 'y': str(espschema)},

   506                              ask_confirm=False)

   507             self.rqlexecall(ss.updateeschema2rql(eschema, repoeschema.eid),

   508                             ask_confirm=self.verbosity >= 2)

   509         if syncperms:

   510             self._synchronize_permissions(eschema, repoeschema.eid)

   511         if syncrdefs:

   512             for rschema, targettypes, role in eschema.relation_definitions(True):

   513                 if rschema in VIRTUAL_RTYPES:

   514                     continue

   515                 if role == 'subject':

   516                     if not rschema in repoeschema.subject_relations():

   517                         continue

   518                     subjtypes, objtypes = [etype], targettypes

   519                 else: # role == 'object'

   520                     if not rschema in repoeschema.object_relations():

   521                         continue

   522                     subjtypes, objtypes = targettypes, [etype]

   523                 self._synchronize_rschema(rschema, syncrdefs=False,

   524                                           syncprops=syncprops, syncperms=syncperms)

   525                 if rschema.rule: # rdef for computed rtype are infered hence should not be

   526                                  # synchronized

   527                     continue

   528                 reporschema = self.repo.schema.rschema(rschema)

   529                 for subj in subjtypes:

   530                     for obj in objtypes:

   531                         if (subj, obj) not in reporschema.rdefs:

   532                             continue

   533                         self._synchronize_rdef_schema(subj, rschema, obj,

   534                                                       syncprops=syncprops, syncperms=syncperms)

   535         if syncprops: # need to process __unique_together__ after rdefs were processed

   536             # mappings from constraint name to columns

   537             # filesystem (fs) and repository (repo) wise

   538             fs = {}

   539             repo = {}

   540             for cols in eschema._unique_together or ():

   541                 fs[unique_index_name(repoeschema, cols)] = sorted(cols)

   542             schemaentity = self.cnx.entity_from_eid(repoeschema.eid)

   543             for entity in schemaentity.related('constraint_of', 'object',

   544                                                targettypes=('CWUniqueTogetherConstraint',)).entities():

   545                 repo[entity.name] = sorted(rel.name for rel in entity.relations)

   546             added = set(fs) - set(repo)

   547             removed = set(repo) - set(fs)

   548 

   549             for name in removed:

   550                 self.rqlexec('DELETE CWUniqueTogetherConstraint C WHERE C name %(name)s',

   551                              {'name': name})

   552 

   553             def possible_unique_constraint(cols):

   554                 for name in cols:

   555                     rschema = repoeschema.subjrels.get(name)

   556                     if rschema is None:

   557                         print('dont add %s unique constraint on %s, missing %s' % (

   558                             ','.join(cols), eschema, name))

   559                         return False

   560                     if not (rschema.final or rschema.inlined):

   561                         print('dont add %s unique constraint on %s, %s is neither final nor inlined' % (

   562                             ','.join(cols), eschema, name))

   563                         return False

   564                 return True

   565 

   566             for name in added:

   567                 if possible_unique_constraint(fs[name]):

   568                     rql, substs = ss._uniquetogether2rql(eschema, fs[name])

   569                     substs['x'] = repoeschema.eid

   570                     substs['name'] = name

   571                     self.rqlexec(rql, substs)

   572 

   573     def _synchronize_rdef_schema(self, subjtype, rtype, objtype,

   574                                  syncperms=True, syncprops=True):

   575         """synchronize properties of the persistent relation definition schema

   576         against its current definition:

   577         * order and other properties

   578         * constraints

   579         * permissions

   580         """

   581         subjtype, objtype = str(subjtype), str(objtype)

   582         rschema = self.fs_schema.rschema(rtype)

   583         if rschema.rule:

   584             raise ExecutionError('Cannot synchronize a relation definition for a '

   585                                  'computed relation (%s)' % rschema)

   586         reporschema = self.repo.schema.rschema(rschema)

   587         if (subjtype, rschema, objtype) in self._synchronized:

   588             return

   589         if syncperms and syncprops:

   590             self._synchronized.add((subjtype, rschema, objtype))

   591             if rschema.symmetric:

   592                 self._synchronized.add((objtype, rschema, subjtype))

   593         rdef = rschema.rdef(subjtype, objtype)

   594         if rdef.infered:

   595             return # don't try to synchronize infered relation defs

   596         repordef = reporschema.rdef(subjtype, objtype)

   597         confirm = self.verbosity >= 2

   598         if syncprops:

   599             # properties

   600             self.rqlexecall(ss.updaterdef2rql(rdef, repordef.eid),

   601                             ask_confirm=confirm)

   602             # constraints

   603             # 0. eliminate the set of unmodified constraints from the sets of

   604             # old/new constraints

   605             newconstraints = set(rdef.constraints)

   606             oldconstraints = set(repordef.constraints)

   607             unchanged_constraints = newconstraints & oldconstraints

   608             newconstraints -= unchanged_constraints

   609             oldconstraints -= unchanged_constraints

   610             # 1. remove old constraints and update constraints of the same type

   611             # NOTE: don't use rschema.constraint_by_type because it may be

   612             #       out of sync with newconstraints when multiple

   613             #       constraints of the same type are used

   614             for cstr in oldconstraints:

   615                 self.rqlexec('DELETE CWConstraint C WHERE C eid %(x)s',

   616                              {'x': cstr.eid}, ask_confirm=confirm)

   617             # 2. add new constraints

   618             cstrtype_map = self.cstrtype_mapping()

   619             self.rqlexecall(ss.constraints2rql(cstrtype_map, newconstraints,

   620                                                repordef.eid),

   621                             ask_confirm=confirm)

   622         if syncperms and not rschema in VIRTUAL_RTYPES:

   623             self._synchronize_permissions(rdef, repordef.eid)

   624 

   625     # base actions ############################################################

   626 

   627     def checkpoint(self, ask_confirm=True):

   628         """checkpoint action"""

   629         if not ask_confirm or self.confirm('Commit now ?', shell=False):

   630             self.commit()

   631 

   632     def cmd_add_cube(self, cube, update_database=True):

   633         self.cmd_add_cubes( (cube,), update_database)

   634 

   635     def cmd_add_cubes(self, cubes, update_database=True):

   636         """update_database is telling if the database schema should be updated

   637         or if only the relevant eproperty should be inserted (for the case where

   638         a cube has been extracted from an existing instance, so the

   639         cube schema is already in there)

   640         """

   641         newcubes = super(ServerMigrationHelper, self).cmd_add_cubes(cubes)

   642         if not newcubes:

   643             return

   644         for cube in newcubes:

   645             self.cmd_set_property('system.version.'+cube,

   646                                   self.config.cube_version(cube))

   647             # ensure added cube is in config cubes

   648             # XXX worth restoring on error?

   649             if not cube in self.config._cubes:

   650                 self.config._cubes += (cube,)

   651         if not update_database:

   652             self.commit()

   653             return

   654         newcubes_schema = self.config.load_schema(construction_mode='non-strict')

   655         # XXX we have to replace fs_schema, used in cmd_add_relation_type

   656         # etc. and fsschema of migration script contexts

   657         self.fs_schema = newcubes_schema

   658         self.update_context('fsschema', self.fs_schema)

   659         new = set()

   660         # execute pre-create files

   661         driver = self.repo.system_source.dbdriver

   662         for cube in reversed(newcubes):

   663             self.cmd_install_custom_sql_scripts(cube)

   664             self.cmd_exec_event_script('precreate', cube)

   665         # add new entity and relation types

   666         for rschema in newcubes_schema.relations():

   667             if not rschema in self.repo.schema:

   668                 self.cmd_add_relation_type(rschema.type)

   669                 new.add(rschema.type)

   670         toadd = [eschema for eschema in newcubes_schema.entities()

   671                  if not eschema in self.repo.schema]

   672         for eschema in order_eschemas(toadd):

   673             self.cmd_add_entity_type(eschema.type)

   674             new.add(eschema.type)

   675         # check if attributes has been added to existing entities

   676         for rschema in newcubes_schema.relations():

   677             existingschema = self.repo.schema.rschema(rschema.type)

   678             for (fromtype, totype) in rschema.rdefs:

   679                 # if rdef already exists or is infered from inheritance,

   680                 # don't add it

   681                 if (fromtype, totype) in existingschema.rdefs \

   682                         or rschema.rdefs[(fromtype, totype)].infered:

   683                     continue

   684                 # check we should actually add the relation definition

   685                 if not (fromtype in new or totype in new or rschema in new):

   686                     continue

   687                 self.cmd_add_relation_definition(str(fromtype), rschema.type,

   688                                                  str(totype))

   689         # execute post-create files

   690         for cube in reversed(newcubes):

   691             with self.cnx.allow_all_hooks_but():

   692                 self.cmd_exec_event_script('postcreate', cube)

   693                 self.commit()

   694 

   695     def cmd_drop_cube(self, cube, removedeps=False):

   696         removedcubes = super(ServerMigrationHelper, self).cmd_drop_cube(

   697             cube, removedeps)

   698         if not removedcubes:

   699             return

   700         fsschema = self.fs_schema

   701         removedcubes_schema = self.config.load_schema(construction_mode='non-strict')

   702         reposchema = self.repo.schema

   703         # execute pre-remove files

   704         for cube in reversed(removedcubes):

   705             self.cmd_exec_event_script('preremove', cube)

   706         # remove cubes'entity and relation types

   707         for rschema in fsschema.relations():

   708             if not rschema in removedcubes_schema and rschema in reposchema:

   709                 self.cmd_drop_relation_type(rschema.type)

   710         toremove = [eschema for eschema in fsschema.entities()

   711                     if not eschema in removedcubes_schema

   712                     and eschema in reposchema]

   713         for eschema in reversed(order_eschemas(toremove)):

   714             self.cmd_drop_entity_type(eschema.type)

   715         for rschema in fsschema.relations():

   716             if rschema in removedcubes_schema and rschema in reposchema:

   717                 # check if attributes/relations has been added to entities from

   718                 # other cubes

   719                 for fromtype, totype in rschema.rdefs:

   720                     if (fromtype, totype) not in removedcubes_schema[rschema.type].rdefs and \

   721                            (fromtype, totype) in reposchema[rschema.type].rdefs:

   722                         self.cmd_drop_relation_definition(

   723                             str(fromtype), rschema.type, str(totype))

   724         # execute post-remove files

   725         for cube in reversed(removedcubes):

   726             self.cmd_exec_event_script('postremove', cube)

   727             self.rqlexec('DELETE CWProperty X WHERE X pkey %(pk)s',

   728                          {'pk': u'system.version.'+cube}, ask_confirm=False)

   729             self.commit()

   730 

   731     # schema migration actions ################################################

   732 

   733     def cmd_add_attribute(self, etype, attrname, attrtype=None, commit=True):

   734         """add a new attribute on the given entity type"""

   735         if attrtype is None:

   736             rschema = self.fs_schema.rschema(attrname)

   737             attrtype = rschema.objects(etype)[0]

   738         self.cmd_add_relation_definition(etype, attrname, attrtype, commit=commit)

   739 

   740     def cmd_drop_attribute(self, etype, attrname, commit=True):

   741         """drop an existing attribute from the given entity type

   742 

   743         `attrname` is a string giving the name of the attribute to drop

   744         """

   745         try:

   746             rschema = self.repo.schema.rschema(attrname)

   747             attrtype = rschema.objects(etype)[0]

   748         except KeyError:

   749             print('warning: attribute %s %s is not known, skip deletion' % (

   750                 etype, attrname))

   751         else:

   752             self.cmd_drop_relation_definition(etype, attrname, attrtype,

   753                                               commit=commit)

   754 

   755     def cmd_rename_attribute(self, etype, oldname, newname, commit=True):

   756         """rename an existing attribute of the given entity type

   757 

   758         `oldname` is a string giving the name of the existing attribute

   759         `newname` is a string giving the name of the renamed attribute

   760         """

   761         eschema = self.fs_schema.eschema(etype)

   762         attrtype = eschema.destination(newname)

   763         # have to commit this first step anyway to get the definition

   764         # actually in the schema

   765         self.cmd_add_attribute(etype, newname, attrtype, commit=True)

   766         # skipp NULL values if the attribute is required

   767         rql = 'SET X %s VAL WHERE X is %s, X %s VAL' % (newname, etype, oldname)

   768         card = eschema.rdef(newname).cardinality[0]

   769         if card == '1':

   770             rql += ', NOT X %s NULL' % oldname

   771         self.rqlexec(rql, ask_confirm=self.verbosity>=2)

   772         # XXX if both attributes fulltext indexed, should skip fti rebuild

   773         # XXX if old attribute was fti indexed but not the new one old value

   774         # won't be removed from the index (this occurs on other kind of

   775         # fulltextindexed change...)

   776         self.cmd_drop_attribute(etype, oldname, commit=commit)

   777 

   778     def cmd_add_entity_type(self, etype, auto=True, commit=True):

   779         """register a new entity type

   780 

   781         in auto mode, automatically register entity's relation where the

   782         targeted type is known

   783         """

   784         instschema = self.repo.schema

   785         eschema = self.fs_schema.eschema(etype)

   786         if etype in instschema and not (eschema.final and eschema.eid is None):

   787             print('warning: %s already known, skip addition' % etype)

   788             return

   789         confirm = self.verbosity >= 2

   790         groupmap = self.group_mapping()

   791         cstrtypemap = self.cstrtype_mapping()

   792         # register the entity into CWEType

   793         execute = self.cnx.execute

   794         if eschema.final and eschema not in instschema:

   795             # final types are expected to be in the living schema by default, but they are not if

   796             # the type is defined in a cube that is being added

   797             edef = EntityType(eschema.type, __permissions__=eschema.permissions)

   798             instschema.add_entity_type(edef)

   799         ss.execschemarql(execute, eschema, ss.eschema2rql(eschema, groupmap))

   800         # add specializes relation if needed

   801         specialized = eschema.specializes()

   802         if specialized:

   803             try:

   804                 specialized.eid = instschema[specialized].eid

   805             except KeyError:

   806                 raise ExecutionError('trying to add entity type but parent type is '

   807                                      'not yet in the database schema')

   808             self.rqlexecall(ss.eschemaspecialize2rql(eschema), ask_confirm=confirm)

   809         # register entity's attributes

   810         for rschema, attrschema in eschema.attribute_definitions():

   811             # ignore those meta relations, they will be automatically added

   812             if rschema.type in META_RTYPES:

   813                 continue

   814             if not attrschema.type in instschema:

   815                 self.cmd_add_entity_type(attrschema.type, False, False)

   816             if not rschema.type in instschema:

   817                 # need to add the relation type and to commit to get it

   818                 # actually in the schema

   819                 self.cmd_add_relation_type(rschema.type, False, commit=True)

   820             # register relation definition

   821             rdef = self._get_rdef(rschema, eschema, eschema.destination(rschema))

   822             ss.execschemarql(execute, rdef, ss.rdef2rql(rdef, cstrtypemap, groupmap),)

   823         # take care to newly introduced base class

   824         # XXX some part of this should probably be under the "if auto" block

   825         for spschema in eschema.specialized_by(recursive=False):

   826             try:

   827                 instspschema = instschema[spschema]

   828             except KeyError:

   829                 # specialized entity type not in schema, ignore

   830                 continue

   831             if instspschema.specializes() != eschema:

   832                 self.rqlexec('SET D specializes P WHERE D eid %(d)s, P name %(pn)s',

   833                              {'d': instspschema.eid, 'pn': eschema.type},

   834                              ask_confirm=confirm)

   835                 for rschema, tschemas, role in spschema.relation_definitions(True):

   836                     for tschema in tschemas:

   837                         if not tschema in instschema:

   838                             continue

   839                         if role == 'subject':

   840                             subjschema = spschema

   841                             objschema = tschema

   842                             if rschema.final and rschema in instspschema.subjrels:

   843                                 # attribute already set, has_rdef would check if

   844                                 # it's of the same type, we don't want this so

   845                                 # simply skip here

   846                                 continue

   847                         elif role == 'object':

   848                             subjschema = tschema

   849                             objschema = spschema

   850                         if (rschema.rdef(subjschema, objschema).infered

   851                             or (instschema.has_relation(rschema) and

   852                                 (subjschema, objschema) in instschema[rschema].rdefs)):

   853                             continue

   854                         self.cmd_add_relation_definition(

   855                             subjschema.type, rschema.type, objschema.type)

   856         if auto:

   857             # we have commit here to get relation types actually in the schema

   858             self.commit()

   859             added = []

   860             for rschema in eschema.subject_relations():

   861                 # attribute relation have already been processed and

   862                 # 'owned_by'/'created_by' will be automatically added

   863                 if rschema.final or rschema.type in META_RTYPES:

   864                     continue

   865                 rtypeadded = rschema.type in instschema

   866                 for targetschema in rschema.objects(etype):

   867                     # ignore relations where the targeted type is not in the

   868                     # current instance schema

   869                     targettype = targetschema.type

   870                     if not targettype in instschema and targettype != etype:

   871                         continue

   872                     if not rtypeadded:

   873                         # need to add the relation type and to commit to get it

   874                         # actually in the schema

   875                         added.append(rschema.type)

   876                         self.cmd_add_relation_type(rschema.type, False, commit=True)

   877                         rtypeadded = True

   878                     # register relation definition

   879                     # remember this two avoid adding twice non symmetric relation

   880                     # such as "Emailthread forked_from Emailthread"

   881                     added.append((etype, rschema.type, targettype))

   882                     rdef = self._get_rdef(rschema, eschema, targetschema)

   883                     ss.execschemarql(execute, rdef,

   884                                      ss.rdef2rql(rdef, cstrtypemap, groupmap))

   885             for rschema in eschema.object_relations():

   886                 if rschema.type in META_RTYPES:

   887                     continue

   888                 rtypeadded = rschema.type in instschema or rschema.type in added

   889                 for targetschema in rschema.subjects(etype):

   890                     # ignore relations where the targeted type is not in the

   891                     # current instance schema

   892                     targettype = targetschema.type

   893                     # don't check targettype != etype since in this case the

   894                     # relation has already been added as a subject relation

   895                     if not targettype in instschema:

   896                         continue

   897                     if not rtypeadded:

   898                         # need to add the relation type and to commit to get it

   899                         # actually in the schema

   900                         self.cmd_add_relation_type(rschema.type, False, commit=True)

   901                         rtypeadded = True

   902                     elif (targettype, rschema.type, etype) in added:

   903                         continue

   904                     # register relation definition

   905                     rdef = self._get_rdef(rschema, targetschema, eschema)

   906                     ss.execschemarql(execute, rdef,

   907                                      ss.rdef2rql(rdef, cstrtypemap, groupmap))

   908         if commit:

   909             self.commit()

   910 

   911     def cmd_drop_entity_type(self, etype, commit=True):

   912         """Drop an existing entity type.

   913 

   914         This will trigger deletion of necessary relation types and definitions.

   915         Note that existing entities of the given type will be deleted without

   916         any hooks called.

   917         """

   918         # XXX what if we delete an entity type which is specialized by other types

   919         # unregister the entity from CWEType

   920         self.rqlexec('DELETE CWEType X WHERE X name %(etype)s', {'etype': etype},

   921                      ask_confirm=self.verbosity>=2)

   922         if commit:

   923             self.commit()

   924 

   925     def cmd_rename_entity_type(self, oldname, newname, attrs=None, commit=True):

   926         """rename an existing entity type in the persistent schema

   927 

   928         `oldname` is a string giving the name of the existing entity type

   929         `newname` is a string giving the name of the renamed entity type

   930         """

   931         schema = self.repo.schema

   932         if oldname not in schema:

   933             print('warning: entity type %s is unknown, skip renaming' % oldname)

   934             return

   935         # if merging two existing entity types

   936         if newname in schema:

   937             assert oldname in ETYPE_NAME_MAP, \

   938                    '%s should be mapped to %s in ETYPE_NAME_MAP' % (oldname,

   939                                                                     newname)

   940             if attrs is None:

   941                 attrs = ','.join(SQL_PREFIX + rschema.type

   942                                  for rschema in schema[newname].subject_relations()

   943                                  if (rschema.final or rschema.inlined)

   944                                  and not rschema in PURE_VIRTUAL_RTYPES)

   945             else:

   946                 attrs += ('eid', 'creation_date', 'modification_date', 'cwuri')

   947                 attrs = ','.join(SQL_PREFIX + attr for attr in attrs)

   948             self.sqlexec('INSERT INTO %s%s(%s) SELECT %s FROM %s%s' % (

   949                 SQL_PREFIX, newname, attrs, attrs, SQL_PREFIX, oldname),

   950                          ask_confirm=False)

   951             # old entity type has not been added to the schema, can't gather it

   952             new = schema.eschema(newname)

   953             oldeid = self.rqlexec('CWEType ET WHERE ET name %(on)s',

   954                                   {'on': oldname}, ask_confirm=False)[0][0]

   955             # backport old type relations to new type

   956             # XXX workflows, other relations?

   957             for r1, rr1 in [('from_entity', 'to_entity'),

   958                             ('to_entity', 'from_entity')]:

   959                 self.rqlexec('SET X %(r1)s NET WHERE X %(r1)s OET, '

   960                              'NOT EXISTS(X2 %(r1)s NET, X relation_type XRT, '

   961                              'X2 relation_type XRT, X %(rr1)s XTE, X2 %(rr1)s XTE), '

   962                              'OET eid %%(o)s, NET eid %%(n)s' % locals(),

   963                              {'o': oldeid, 'n': new.eid}, ask_confirm=False)

   964             # backport is / is_instance_of relation to new type

   965             for rtype in ('is', 'is_instance_of'):

   966                 self.sqlexec('UPDATE %s_relation SET eid_to=%s WHERE eid_to=%s'

   967                              % (rtype, new.eid, oldeid), ask_confirm=False)

   968             # delete relations using SQL to avoid relations content removal

   969             # triggered by schema synchronization hooks.

   970             for rdeftype in ('CWRelation', 'CWAttribute'):

   971                 thispending = set( (eid for eid, in self.sqlexec(

   972                     'SELECT cw_eid FROM cw_%s WHERE cw_from_entity=%%(eid)s OR '

   973                     ' cw_to_entity=%%(eid)s' % rdeftype,

   974                     {'eid': oldeid}, ask_confirm=False)) )

   975                 # we should add deleted eids into pending eids else we may

   976                 # get some validation error on commit since integrity hooks

   977                 # may think some required relation is missing... This also ensure

   978                 # repository caches are properly cleanup

   979                 hook.CleanupDeletedEidsCacheOp.get_instance(self.cnx).union(thispending)

   980                 # and don't forget to remove record from system tables

   981                 entities = [self.cnx.entity_from_eid(eid, rdeftype) for eid in thispending]

   982                 self.repo.system_source.delete_info_multi(self.cnx, entities)

   983                 self.sqlexec('DELETE FROM cw_%s WHERE cw_from_entity=%%(eid)s OR '

   984                              'cw_to_entity=%%(eid)s' % rdeftype,

   985                              {'eid': oldeid}, ask_confirm=False)

   986                 # now we have to manually cleanup relations pointing to deleted

   987                 # entities

   988                 thiseids = ','.join(str(eid) for eid in thispending)

   989                 for rschema, ttypes, role in schema[rdeftype].relation_definitions():

   990                     if rschema.type in VIRTUAL_RTYPES:

   991                         continue

   992                     sqls = []

   993                     if role == 'object':

   994                         if rschema.inlined:

   995                             for eschema in ttypes:

   996                                 sqls.append('DELETE FROM cw_%s WHERE cw_%s IN(%%s)'

   997                                             % (eschema, rschema))

   998                         else:

   999                             sqls.append('DELETE FROM %s_relation WHERE eid_to IN(%%s)'

  1000                                         % rschema)

  1001                     elif not rschema.inlined:

  1002                         sqls.append('DELETE FROM %s_relation WHERE eid_from IN(%%s)'

  1003                                     % rschema)

  1004                     for sql in sqls:

  1005                         self.sqlexec(sql % thiseids, ask_confirm=False)

  1006             # remove the old type: use rql to propagate deletion

  1007             self.rqlexec('DELETE CWEType ET WHERE ET name %(on)s', {'on': oldname},

  1008                          ask_confirm=False)

  1009         # elif simply renaming an entity type

  1010         else:

  1011             self.rqlexec('SET ET name %(newname)s WHERE ET is CWEType, ET name %(on)s',

  1012                          {'newname' : text_type(newname), 'on' : oldname},

  1013                          ask_confirm=False)

  1014         if commit:

  1015             self.commit()

  1016 

  1017     def cmd_add_relation_type(self, rtype, addrdef=True, commit=True):

  1018         """register a new relation type named `rtype`, as described in the

  1019         schema description file.

  1020 

  1021         `addrdef` is a boolean value; when True, it will also add all relations

  1022         of the type just added found in the schema definition file. Note that it

  1023         implies an intermediate "commit" which commits the relation type

  1024         creation (but not the relation definitions themselves, for which

  1025         committing depends on the `commit` argument value).

  1026 

  1027         """

  1028         reposchema = self.repo.schema

  1029         rschema = self.fs_schema.rschema(rtype)

  1030         execute = self.cnx.execute

  1031         if rtype in reposchema:

  1032             print('warning: relation type %s is already known, skip addition' % (

  1033                 rtype))

  1034         elif rschema.rule:

  1035             gmap = self.group_mapping()

  1036             ss.execschemarql(execute, rschema, ss.crschema2rql(rschema, gmap))

  1037         else:

  1038             # register the relation into CWRType and insert necessary relation

  1039             # definitions

  1040             ss.execschemarql(execute, rschema, ss.rschema2rql(rschema, addrdef=False))

  1041         if not rschema.rule and addrdef:

  1042             self.commit()

  1043             gmap = self.group_mapping()

  1044             cmap = self.cstrtype_mapping()

  1045             done = set()

  1046             for subj, obj in rschema.rdefs:

  1047                 if not (reposchema.has_entity(subj)

  1048                         and reposchema.has_entity(obj)):

  1049                     continue

  1050                 # symmetric relations appears twice

  1051                 if (subj, obj) in done:

  1052                     continue

  1053                 done.add( (subj, obj) )

  1054                 self.cmd_add_relation_definition(subj, rtype, obj)

  1055             if rtype in META_RTYPES:

  1056                 # if the relation is in META_RTYPES, ensure we're adding it for

  1057                 # all entity types *in the persistent schema*, not only those in

  1058                 # the fs schema

  1059                 for etype in self.repo.schema.entities():

  1060                     if not etype in self.fs_schema:

  1061                         # get sample object type and rproperties

  1062                         objtypes = rschema.objects()

  1063                         assert len(objtypes) == 1, objtypes

  1064                         objtype = objtypes[0]

  1065                         rdef = copy(rschema.rdef(rschema.subjects(objtype)[0], objtype))

  1066                         rdef.subject = etype

  1067                         rdef.rtype = self.repo.schema.rschema(rschema)

  1068                         rdef.object = self.repo.schema.eschema(objtype)

  1069                         ss.execschemarql(execute, rdef,

  1070                                          ss.rdef2rql(rdef, cmap, gmap))

  1071         if commit:

  1072             self.commit()

  1073 

  1074     def cmd_drop_relation_type(self, rtype, commit=True):

  1075         """Drop an existing relation type.

  1076 

  1077         Note that existing relations of the given type will be deleted without

  1078         any hooks called.

  1079         """

  1080         self.rqlexec('DELETE CWRType X WHERE X name %r' % rtype,

  1081                      ask_confirm=self.verbosity>=2)

  1082         self.rqlexec('DELETE CWComputedRType X WHERE X name %r' % rtype,

  1083                      ask_confirm=self.verbosity>=2)

  1084         if commit:

  1085             self.commit()

  1086 

  1087     def cmd_rename_relation_type(self, oldname, newname, commit=True, force=False):

  1088         """rename an existing relation

  1089 

  1090         `oldname` is a string giving the name of the existing relation

  1091         `newname` is a string giving the name of the renamed relation

  1092 

  1093         If `force` is True, proceed even if `oldname` still appears in the fs schema

  1094         """

  1095         if oldname in self.fs_schema and not force:

  1096             if not self.confirm('Relation %s is still present in the filesystem schema,'

  1097                                 ' do you really want to drop it?' % oldname,

  1098                                 default='n'):

  1099                 return

  1100         self.cmd_add_relation_type(newname, commit=True)

  1101         if not self.repo.schema[oldname].rule:

  1102             self.rqlexec('SET X %s Y WHERE X %s Y' % (newname, oldname),

  1103                          ask_confirm=self.verbosity>=2)

  1104         self.cmd_drop_relation_type(oldname, commit=commit)

  1105 

  1106     def cmd_add_relation_definition(self, subjtype, rtype, objtype, commit=True):

  1107         """register a new relation definition, from its definition found in the

  1108         schema definition file

  1109         """

  1110         rschema = self.fs_schema.rschema(rtype)

  1111         if rschema.rule:

  1112             raise ExecutionError('Cannot add a relation definition for a '

  1113                                  'computed relation (%s)' % rschema)

  1114         if not rtype in self.repo.schema:

  1115             self.cmd_add_relation_type(rtype, addrdef=False, commit=True)

  1116         if (subjtype, objtype) in self.repo.schema.rschema(rtype).rdefs:

  1117             print('warning: relation %s %s %s is already known, skip addition' % (

  1118                 subjtype, rtype, objtype))

  1119             return

  1120         rdef = self._get_rdef(rschema, subjtype, objtype)

  1121         ss.execschemarql(self.cnx.execute, rdef,

  1122                          ss.rdef2rql(rdef, self.cstrtype_mapping(),

  1123                                      self.group_mapping()))

  1124         if commit:

  1125             self.commit()

  1126 

  1127     def _get_rdef(self, rschema, subjtype, objtype):

  1128         return self._set_rdef_eid(rschema.rdefs[(subjtype, objtype)])

  1129 

  1130     def _set_rdef_eid(self, rdef):

  1131         for attr in ('rtype', 'subject', 'object'):

  1132             schemaobj = getattr(rdef, attr)

  1133             if getattr(schemaobj, 'eid', None) is None:

  1134                 schemaobj.eid =  self.repo.schema[schemaobj].eid