    001    //$HeadURL: https://svn.wald.intevation.org/svn/deegree/base/branches/2.4_testing/src/org/deegree/security/drm/SecurityRegistry.java $
    002    /*----------------------------------------------------------------------------
    003     This file is part of deegree, http://deegree.org/
    004     Copyright (C) 2001-2009 by:
    005       Department of Geography, University of Bonn
    006     and
    007       lat/lon GmbH
    008
    009     This library is free software; you can redistribute it and/or modify it under
    010     the terms of the GNU Lesser General Public License as published by the Free
    011     Software Foundation; either version 2.1 of the License, or (at your option)
    012     any later version.
    013     This library is distributed in the hope that it will be useful, but WITHOUT
    014     ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
    015     FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
    016     details.
    017     You should have received a copy of the GNU Lesser General Public License
    018     along with this library; if not, write to the Free Software Foundation, Inc.,
    019     59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
    020
    021     Contact information:
    022
    023     lat/lon GmbH
    024     Aennchenstr. 19, 53177 Bonn
    025     Germany
    026     http://lat-lon.de/
    027
    028     Department of Geography, University of Bonn
    029     Prof. Dr. Klaus Greve
    030     Postfach 1147, 53001 Bonn
    031     Germany
    032     http://www.geographie.uni-bonn.de/deegree/
    033
    034     e-mail: info@deegree.org
    035    ----------------------------------------------------------------------------*/
    036    package org.deegree.security.drm;
    037
    038    import java.util.LinkedList;
    039    import java.util.List;
    040    import java.util.Properties;
    041
    042    import org.deegree.framework.util.StringPair;
    043    import org.deegree.security.GeneralSecurityException;
    044    import org.deegree.security.drm.model.Group;
    045    import org.deegree.security.drm.model.Privilege;
    046    import org.deegree.security.drm.model.Right;
    047    import org.deegree.security.drm.model.RightType;
    048    import org.deegree.security.drm.model.Role;
    049    import org.deegree.security.drm.model.SecurableObject;
    050    import org.deegree.security.drm.model.SecuredObject;
    051    import org.deegree.security.drm.model.Service;
    052    import org.deegree.security.drm.model.User;
    053
    054    /**
    055     * This is an interface for datastores that are able to stores the following object types and their relations:
    056     * <ul>
    057     * <li><code>User</code>
    058     * <li><code>Group</code>
    059     * <li><code>Role</code>
    060     * <li><code>SecurableObject</code>
    061     * <li><code>Right / RightType</code>
    062     * <li><code>Privilege</code>
    063     * </ul>
    064     *
    065     * @author <a href="mailto:mschneider@lat-lon.de">Markus Schneider </a>
    066     * @version $Revision: 18195 $
    067     */
    068    public interface SecurityRegistry {
    069
    070        /**
    071         * Initializes the <code>Registry</code> -instance according to the contents of the submitted
    072         * <code>Properties</code>.
    073         * <p>
    074         * The supported keys and values depend on the concrete implementation.
    075         *
    076         * @param properties
    077         * @throws GeneralSecurityException
    078         */
    079        void initialize( Properties properties )
    080                                throws GeneralSecurityException;
    081
    082        /**
    083         * Signals the <code>Registry</code> that a new transaction starts.
    084         * <p>
    085         * Only one transaction can be active at a time.
    086         *
    087         * @param transaction
    088         *
    089         * @throws GeneralSecurityException
    090         */
    091        void beginTransaction( SecurityTransaction transaction )
    092                                throws GeneralSecurityException;
    093
    094        /**
    095         * Signals the <code>Registry</code> that the current transaction ends. Changes made during the transaction are now
    096         * made persistent.
    097         *
    098         * @param transaction
    099         *
    100         * @throws GeneralSecurityException
    101         */
    102        void commitTransaction( SecurityTransaction transaction )
    103                                throws GeneralSecurityException;
    104
    105        /**
    106         * Signals the <code>Registry</code> that the transaction shall be aborted. Changes made by the transaction are
    107         * undone.
    108         *
    109         * @param transaction
    110         *
    111         * @throws GeneralSecurityException
    112         */
    113        void abortTransaction( SecurityTransaction transaction )
    114                                throws GeneralSecurityException;
    115
    116        /**
    117         * Deletes all data from the <code>Registry</code> and sets the default objects (SEC_ADMIN user, role and group) and
    118         * standard rights and privileges.
    119         *
    120         * @param transaction
    121         * @throws GeneralSecurityException
    122         */
    123        void clean( SecurityTransaction transaction )
    124                                throws GeneralSecurityException;
    125
    126        /**
    127         * Adds a new User-account to the <code>Registry</code>.
    128         *
    129         * @param transaction
    130         * @param name
    131         * @param password
    132         * @param lastName
    133         * @param firstName
    134         * @param mailAddress
    135         * @return the new user
    136         *
    137         * @throws GeneralSecurityException
    138         *             this is a <code>DuplicateException</code> if the group already existed
    139         */
    140        User registerUser( SecurityTransaction transaction, String name, String password, String lastName,
    141                           String firstName, String mailAddress )
    142                                throws GeneralSecurityException;
    143
    144        /**
    145         * Removes an existing <code>User<code> from the <code>Registry</code>.
    146         *
    147         * @param transaction
    148         * @param user
    149         *
    150         * @throws GeneralSecurityException
    151         */
    152        void deregisterUser( SecurityTransaction transaction, User user )
    153                                throws GeneralSecurityException;
    154
    155        /**
    156         * Updates the metadata (name, email, etc.) of a <code>User</code> in the <code>Registry</code>.
    157         *
    158         * @param transaction
    159         * @param user
    160         *
    161         * @throws GeneralSecurityException
    162         *             this is a <code>DuplicateException</code> if a user with the new name already existed
    163         */
    164        void updateUser( SecurityTransaction transaction, User user )
    165                                throws GeneralSecurityException;
    166
    167        /**
    168         * Retrieves a <code>User</code> from the <code>Registry</code>.
    169         *
    170         * @param securityAccess
    171         * @param name
    172         * @return the user
    173         *
    174         * @throws GeneralSecurityException
    175         *             this is an <code>UnknownException</code> if the user is not known to the <code>Registry</code>
    176         */
    177        User getUserByName( SecurityAccess securityAccess, String name )
    178                                throws GeneralSecurityException;
    179
    180        /**
    181         * Retrieves a <code>User</code> from the <code>Registry</code>.
    182         *
    183         * @param securityAccess
    184         * @param id
    185         * @return the user
    186         *
    187         * @throws GeneralSecurityException
    188         *             this is an <code>UnknownException</code> if the user is not known to the <code>Registry</code>
    189         */
    190        User getUserById( SecurityAccess securityAccess, int id )
    191                                throws GeneralSecurityException;
    192
    193        /**
    194         * Retrieves all <code>User</code> s from the <code>Registry</code>.
    195         *
    196         * @param securityAccess
    197         * @return the users
    198         *
    199         * @throws GeneralSecurityException
    200         */
    201        User[] getAllUsers( SecurityAccess securityAccess )
    202                                throws GeneralSecurityException;
    203
    204        /**
    205         * Retrieves all <code>Users</code> s from the <code>Registry</code> that are associated DIRECTLY (SecurityAccess
    206         * securityAccess, i.e. not via group memberships) with a given <code>Role</code>.
    207         *
    208         * @param securityAccess
    209         * @param role
    210         * @return the users
    211         *
    212         * @throws GeneralSecurityException
    213         */
    214        User[] getUsersWithRole( SecurityAccess securityAccess, Role role )
    215                                throws GeneralSecurityException;
    216
    217        /**
    218         * Retrieves all <code>User</code> s from the <code>Registry</code> belong to the given <code>Group</code>.
    219         *
    220         * @param securityAccess
    221         * @param group
    222         * @return the users
    223         *
    224         * @throws GeneralSecurityException
    225         */
    226        User[] getUsersInGroup( SecurityAccess securityAccess, Group group )
    227                                throws GeneralSecurityException;
    228
    229        /**
    230         * Sets the <code>User</code> s that are members of a given <code>Group</code>.
    231         *
    232         * @param transaction
    233         * @param group
    234         * @param users
    235         *
    236         * @throws GeneralSecurityException
    237         */
    238        void setUsersInGroup( SecurityTransaction transaction, Group group, User[] users )
    239                                throws GeneralSecurityException;
    240
    241        /**
    242         * Sets the <code>User</code> s that a given <code>Role</code> is associated to.
    243         *
    244         * @param transaction
    245         * @param role
    246         * @param users
    247         *
    248         * @throws GeneralSecurityException
    249         */
    250        void setUsersWithRole( SecurityTransaction transaction, Role role, User[] users )
    251                                throws GeneralSecurityException;
    252
    253        /**
    254         * Adds a new Group-account to the <code>Registry</code>.
    255         *
    256         * @param transaction
    257         * @param name
    258         * @param title
    259         * @return the group
    260         *
    261         * @throws GeneralSecurityException
    262         *             this is a <code>DuplicateException</code> if the group already existed
    263         */
    264        Group registerGroup( SecurityTransaction transaction, String name, String title )
    265                                throws GeneralSecurityException;
    266
    267        /**
    268         * Removes an existing <code>Group</code> from the <code>Registry</code> (including its relations).
    269         *
    270         * @param transaction
    271         * @param group
    272         *
    273         * @throws GeneralSecurityException
    274         */
    275        void deregisterGroup( SecurityTransaction transaction, Group group )
    276                                throws GeneralSecurityException;
    277
    278        /**
    279         * Retrieves a <code>Group</code> from the <code>Registry</code>.
    280         *
    281         * @param securityAccess
    282         * @param name
    283         * @return the group
    284         *
    285         * @throws GeneralSecurityException
    286         *             this is an <code>UnknownException</code> if the group is not known to the <code>Registry</code>
    287         */
    288        Group getGroupByName( SecurityAccess securityAccess, String name )
    289                                throws GeneralSecurityException;
    290
    291        /**
    292         * Retrieves a <code>Group</code> from the <code>Registry</code>.
    293         *
    294         * @param securityAccess
    295         * @param id
    296         * @return the group
    297         *
    298         * @throws GeneralSecurityException
    299         *             this is an <code>UnknownException</code> if the group is not known to the <code>Registry</code>
    300         */
    301        Group getGroupById( SecurityAccess securityAccess, int id )
    302                                throws GeneralSecurityException;
    303
    304        /**
    305         * Retrieves all <code>Group</code> s from the <code>Registry</code>.
    306         *
    307         * @param securityAccess
    308         * @return the groups
    309         *
    310         * @throws GeneralSecurityException
    311         */
    312        Group[] getAllGroups( SecurityAccess securityAccess )
    313                                throws GeneralSecurityException;
    314
    315        /**
    316         * Retrieves all <code>Group</code> s from the <code>Registry</code> that the given <code>User</code> belongs to.
    317         *
    318         * @param securityAccess
    319         * @param user
    320         * @return the groups
    321         *
    322         * @throws GeneralSecurityException
    323         */
    324        Group[] getGroupsForUser( SecurityAccess securityAccess, User user )
    325                                throws GeneralSecurityException;
    326
    327        /**
    328         * Retrieves all <code>Group</code> s from the <code>Registry</code> that the given <code>Group</code> belongs to.
    329         *
    330         * @param securityAccess
    331         * @param group
    332         * @return the groups
    333         *
    334         * @throws GeneralSecurityException
    335         */
    336        Group[] getGroupsForGroup( SecurityAccess securityAccess, Group group )
    337                                throws GeneralSecurityException;
    338
    339        /**
    340         * Retrieves all <code>Group</code> s from the <code>Registry</code> belong to the given <code>Group</code>.
    341         *
    342         * @param securityAccess
    343         * @param group
    344         * @return the groups
    345         *
    346         * @throws GeneralSecurityException
    347         */
    348        Group[] getGroupsInGroup( SecurityAccess securityAccess, Group group )
    349                                throws GeneralSecurityException;
    350
    351        /**
    352         * Retrieves all <code>Group</code> s from the <code>Registry</code> that are associated with a given
    353         * <code>Role</code>.
    354         *
    355         * @param securityAccess
    356         * @param role
    357         * @return the groups
    358         *
    359         * @throws GeneralSecurityException
    360         */
    361        Group[] getGroupsWithRole( SecurityAccess securityAccess, Role role )
    362                                throws GeneralSecurityException;
    363
    364        /**
    365         * Sets the <code>Group</code> s that a given <code>User</code> is a DIRECT member of.
    366         *
    367         * @param transaction
    368         * @param user
    369         * @param groups
    370         *
    371         * @throws GeneralSecurityException
    372         */
    373        void setGroupsForUser( SecurityTransaction transaction, User user, Group[] groups )
    374                                throws GeneralSecurityException;
    375
    376        /**
    377         * Sets the <code>Groups</code> s that are members of a given <code>Group</code>.
    378         *
    379         * @param transaction
    380         * @param group
    381         * @param groups
    382         *
    383         * @throws GeneralSecurityException
    384         */
    385        void setGroupsInGroup( SecurityTransaction transaction, Group group, Group[] groups )
    386                                throws GeneralSecurityException;
    387
    388        /**
    389         * Sets the <code>Group</code> s that a given <code>Role</code> is associated to.
    390         *
    391         * @param transaction
    392         * @param role
    393         * @param groups
    394         *
    395         * @throws GeneralSecurityException
    396         */
    397        void setGroupsWithRole( SecurityTransaction transaction, Role role, Group[] groups )
    398                                throws GeneralSecurityException;
    399
    400        /**
    401         * Sets the <code>Groups</code> s that a given <code>Group</code> is member of DIRECTLY (i.e. not via group
    402         * membership).
    403         *
    404         * @param transaction
    405         * @param group
    406         * @param groups
    407         *
    408         * @throws GeneralSecurityException
    409         */
    410        void setGroupsForGroup( SecurityTransaction transaction, Group group, Group[] groups )
    411                                throws GeneralSecurityException;
    412
    413        /**
    414         * Adds a new role to the <code>Registry</code>.
    415         *
    416         * @param transaction
    417         * @param name
    418         * @return the role
    419         *
    420         * @throws GeneralSecurityException
    421         *             this is a <code>DuplicateException</code> if the role already existed
    422         */
    423        Role registerRole( SecurityTransaction transaction, String name )
    424                                throws GeneralSecurityException;
    425
    426        /**
    427         * Removes an existing <code>Role</code> from the <code>Registry</code> (including its relations).
    428         *
    429         * @param transaction
    430         * @param role
    431         *
    432         * @throws GeneralSecurityException
    433         */
    434        void deregisterRole( SecurityTransaction transaction, Role role )
    435                                throws GeneralSecurityException;
    436
    437        /**
    438         * Retrieves a <code>Role</code> from the <code>Registry</code>.
    439         *
    440         * @param securityAccess
    441         * @param name
    442         * @return the role
    443         *
    444         * @throws GeneralSecurityException
    445         *             this is an <code>UnknownException</code> if the role is not known to the <code>Registry</code>
    446         */
    447        Role getRoleByName( SecurityAccess securityAccess, String name )
    448                                throws GeneralSecurityException;
    449
    450        /**
    451         * Retrieves all <code>Role</code> s from the <code>Registry</code> that have a certain namespace.
    452         *
    453         * @param securityAccess
    454         * @param ns
    455         * @return the roles
    456         *
    457         * @throws GeneralSecurityException
    458         */
    459        Role[] getRolesByNS( SecurityAccess securityAccess, String ns )
    460                                throws GeneralSecurityException;
    461
    462        /**
    463         * Retrieves a <code>Role</code> from the <code>Registry</code>.
    464         *
    465         * @param securityAccess
    466         * @param id
    467         * @return the role
    468         *
    469         * @throws GeneralSecurityException
    470         *             this is an <code>UnknownException</code> if the role is not known to the <code>Registry</code>
    471         */
    472        Role getRoleById( SecurityAccess securityAccess, int id )
    473                                throws GeneralSecurityException;
    474
    475        /**
    476         * Retrieves all <code>Role</code> s from the <code>Registry</code>, except those that are only used internally
    477         * (these end with a $ symbol);
    478         *
    479         * @param securityAccess
    480         * @return the roles
    481         *
    482         * @throws GeneralSecurityException
    483         */
    484        Role[] getAllRoles( SecurityAccess securityAccess )
    485                                throws GeneralSecurityException;
    486
    487        /**
    488         * Retrieves all <code>Role</code> s from the <code>Registry</code> that are associated with a given
    489         * <code>User</code> DIRECTLY (i.e. not via group memberships).
    490         *
    491         * @param securityAccess
    492         * @param user
    493         * @return the roles
    494         *
    495         * @throws GeneralSecurityException
    496         */
    497        Role[] getRolesForUser( SecurityAccess securityAccess, User user )
    498                                throws GeneralSecurityException;
    499
    500        /**
    501         * Retrieves all <code>Role</code> s from the <code>Registry</code> that are associated with a given
    502         * <code>Group</code> DIRECTLY (i.e. not via group memberships).
    503         *
    504         * @param securityAccess
    505         * @param group
    506         * @return the roles
    507         *
    508         * @throws GeneralSecurityException
    509         */
    510        Role[] getRolesForGroup( SecurityAccess securityAccess, Group group )
    511                                throws GeneralSecurityException;
    512
    513        /**
    514         * Sets the <code>Role</code> s that a given <code>User</code> is directly associated to.
    515         *
    516         * @param transaction
    517         * @param user
    518         * @param roles
    519         *
    520         * @throws GeneralSecurityException
    521         */
    522        void setRolesForUser( SecurityTransaction transaction, User user, Role[] roles )
    523                                throws GeneralSecurityException;
    524
    525        /**
    526         * Sets the <code>Role</code> s that a given <code>Group</code> is associated to.
    527         *
    528         * @param transaction
    529         * @param group
    530         * @param roles
    531         *
    532         * @throws GeneralSecurityException
    533         */
    534        void setRolesForGroup( SecurityTransaction transaction, Group group, Role[] roles )
    535                                throws GeneralSecurityException;
    536
    537        /**
    538         * Adds a new <code>SecuredObject</code> to the <code>Registry</code>.
    539         *
    540         * @param transaction
    541         * @param type
    542         * @param name
    543         * @param title
    544         * @return the new object
    545         *
    546         * @throws GeneralSecurityException
    547         *             this is a <code>DuplicateException</code> if the object already existed
    548         */
    549        SecuredObject registerSecuredObject( SecurityTransaction transaction, String type, String name, String title )
    550                                throws GeneralSecurityException;
    551
    552        /**
    553         * Removes an existing <code>SecuredObject</code> from the <code>Registry</code> (including its associated rights).
    554         *
    555         * @param transaction
    556         * @param object
    557         *
    558         * @throws GeneralSecurityException
    559         */
    560        void deregisterSecuredObject( SecurityTransaction transaction, SecuredObject object )
    561                                throws GeneralSecurityException;
    562
    563        /**
    564         * Retrieves a <code>SecuredObject</code> from the <code>Registry</code>.
    565         *
    566         * @param securityAccess
    567         * @param name
    568         * @param type
    569         * @return the object
    570         *
    571         * @throws GeneralSecurityException
    572         *             this is an <code>UnknownException</code> if the <code>SecuredObject</code> is not known to the
    573         *             <code>Registry</code>
    574         */
    575        SecuredObject getSecuredObjectByName( SecurityAccess securityAccess, String name, String type )
    576                                throws GeneralSecurityException;
    577
    578        /**
    579         * Retrieves all <code>SecuredObject</code> s from the <code>Registry</code> that have a certain namespace.
    580         *
    581         * @param securityAccess
    582         * @param ns
    583         * @param type
    584         * @return the objects
    585         *
    586         * @throws GeneralSecurityException
    587         */
    588        SecuredObject[] getSecuredObjectsByNS( SecurityAccess securityAccess, String ns, String type )
    589                                throws GeneralSecurityException;
    590
    591        /**
    592         * Retrieves a <code>SecuredObject</code> from the <code>Registry</code>.
    593         *
    594         * @param securityAccess
    595         * @param id
    596         * @return the object
    597         *
    598         * @throws GeneralSecurityException
    599         *             this is an <code>UnknownException</code> if the <code>SecuredObject</code> is not known to the
    600         *             <code>Registry</code>
    601         */
    602        SecuredObject getSecuredObjectById( SecurityAccess securityAccess, int id )
    603                                throws GeneralSecurityException;
    604
    605        /**
    606         * Retrieves all <code>SecuredObject</code> s from the <code>Registry</code>.
    607         *
    608         * @param securityAccess
    609         * @param type
    610         * @return the objects
    611         *
    612         * @throws GeneralSecurityException
    613         */
    614        SecuredObject[] getAllSecuredObjects( SecurityAccess securityAccess, String type )
    615                                throws GeneralSecurityException;
    616
    617        /**
    618         * Adds a new <code>Privilege</code> to the <code>Registry</code>.
    619         *
    620         * @param transaction
    621         * @param name
    622         * @return the privilege
    623         *
    624         * @throws GeneralSecurityException
    625         *             this is a <code>DuplicateException</code> if the <code>Privilege</code> already existed
    626         */
    627        Privilege registerPrivilege( SecurityTransaction transaction, String name )
    628                                throws GeneralSecurityException;
    629
    630        /**
    631         * Removes an existing</code> Privilege</code> from the <code>Registry </code> (including its relations).
    632         *
    633         * @param transaction
    634         * @param privilege
    635         *
    636         * @throws GeneralSecurityException
    637         */
    638        void deregisterPrivilege( SecurityTransaction transaction, Privilege privilege )
    639                                throws GeneralSecurityException;
    640
    641        /**
    642         * Retrieves a <code>Privilege</code> from the <code>Registry</code>.
    643         *
    644         * @param securityAccess
    645         * @param name
    646         * @return the privilege
    647         *
    648         * @throws GeneralSecurityException
    649         *             this is an <code>UnknownException</code> if the privilege is not known to the <code>Registry</code>
    650         */
    651        Privilege getPrivilegeByName( SecurityAccess securityAccess, String name )
    652                                throws GeneralSecurityException;
    653
    654        /**
    655         * Retrieves all <code>Privileges</code> s from the <code>Registry</code> that are associated with a given
    656         * <code>Role</code>.
    657         *
    658         * @param securityAccess
    659         * @param role
    660         * @return the privileges
    661         *
    662         * @throws GeneralSecurityException
    663         */
    664        Privilege[] getPrivilegesForRole( SecurityAccess securityAccess, Role role )
    665                                throws GeneralSecurityException;
    666
    667        /**
    668         * Sets all <code>Privilege</code> s that are associated with a given <code>Role</code>.
    669         *
    670         * @param transaction
    671         * @param role
    672         * @param privileges
    673         *
    674         * @throws GeneralSecurityException
    675         */
    676        void setPrivilegesForRole( SecurityTransaction transaction, Role role, Privilege[] privileges )
    677                                throws GeneralSecurityException;
    678
    679        /**
    680         * Adds a new <code>RightType</code> to the <code>Registry</code>.
    681         *
    682         * @param transaction
    683         * @param name
    684         * @return the right type
    685         *
    686         * @throws GeneralSecurityException
    687         *             this is a <code>DuplicateException</code> if the <code>RightType</code> already existed
    688         */
    689        RightType registerRightType( SecurityTransaction transaction, String name )
    690                                throws GeneralSecurityException;
    691
    692        /**
    693         * Removes an existing <code>RightType</code> from the <code>Registry</code> (including its relations).
    694         *
    695         * @param transaction
    696         * @param type
    697         *
    698         * @throws GeneralSecurityException
    699         */
    700        void deregisterRightType( SecurityTransaction transaction, RightType type )
    701                                throws GeneralSecurityException;
    702
    703        /**
    704         * Retrieves a <code>RightType</code> from the <code>Registry</code>.
    705         *
    706         * @param securityAccess
    707         * @param name
    708         * @return the right type
    709         *
    710         * @throws GeneralSecurityException
    711         *             this is an <code>UnknownException</code> if the <code>RightType</code> is not known to the
    712         *             <code>Registry</code>
    713         */
    714        RightType getRightTypeByName( SecurityAccess securityAccess, String name )
    715                                throws GeneralSecurityException;
    716
    717        /**
    718         * Retrieves the <code>Rights</code> from the <code>Registry</code> that are associated with a given
    719         * <code>Role</code> and a <code>SecurableObject</code>.
    720         *
    721         * @param securityAccess
    722         * @param object
    723         * @param role
    724         * @return the rights
    725         *
    726         * @throws GeneralSecurityException
    727         */
    728        Right[] getRights( SecurityAccess securityAccess, SecurableObject object, Role role )
    729                                throws GeneralSecurityException;
    730
    731        /**
    732         * Sets the <code>Rights</code> to be associated with a given <code>Role</code> and <code>SecurableObject</code>.
    733         *
    734         * @param transaction
    735         * @param object
    736         * @param role
    737         * @param rights
    738         *
    739         * @throws GeneralSecurityException
    740         */
    741        void setRights( SecurityTransaction transaction, SecurableObject object, Role role, Right[] rights )
    742                                throws GeneralSecurityException;
    743
    744        /**
    745         * Sets one <code>Right</code> to be associated with a given <code>Role</code> and all given
    746         * <code>SecurableObjects</code>.
    747         *
    748         * @param transaction
    749         * @param objects
    750         * @param role
    751         * @param right
    752         *
    753         * @throws GeneralSecurityException
    754         */
    755        void setRights( SecurityTransaction transaction, SecurableObject[] objects, Role role, Right right )
    756                                throws GeneralSecurityException;
    757
    758        /**
    759         * @param access
    760         * @param address
    761         * @return the service
    762         * @throws GeneralSecurityException
    763         */
    764        Service getServiceByAddress( SecurityAccess access, String address )
    765                                throws GeneralSecurityException;
    766
    767        /**
    768         * @param transaction
    769         * @param address
    770         * @param title
    771         * @param objects
    772         * @param type
    773         * @return the new service
    774         * @throws GeneralSecurityException
    775         */
    776        Service registerService( SecurityTransaction transaction, String address, String title, List<StringPair> objects,
    777                                 String type )
    778                                throws GeneralSecurityException;
    779
    780        /**
    781         * @param transaction
    782         * @param service
    783         * @throws GeneralSecurityException
    784         */
    785        void deregisterService( SecurityTransaction transaction, Service service )
    786                                throws GeneralSecurityException;
    787
    788        /**
    789         * @param access
    790         * @return all services
    791         * @throws GeneralSecurityException
    792         */
    793        LinkedList<Service> getAllServices( SecurityAccess access )
    794                                throws GeneralSecurityException;
    795
    796        /**
    797         * @param securityTransaction
    798         * @param oldService
    799         * @param newService
    800         * @throws GeneralSecurityException
    801         */
    802        void updateService( SecurityTransaction securityTransaction, Service oldService, Service newService )
    803                                throws GeneralSecurityException;
    804
    805        /**
    806         * @param securityTransaction
    807         * @param service
    808         * @param oldName
    809         * @param newName
    810         * @throws GeneralSecurityException
    811         */
    812        void renameObject( SecurityTransaction securityTransaction, Service service, String oldName, String newName )
    813                                throws GeneralSecurityException;
    814
    815        /**
    816         * @param securityTransaction
    817         * @param service
    818         * @param newTitle
    819         * @param newAddress
    820         * @throws GeneralSecurityException
    821         */
    822        void editService( SecurityTransaction securityTransaction, Service service, String newTitle, String newAddress )
    823                                throws GeneralSecurityException;
    824
    825    }