change dir structure

1 files changed, 0 insertions, 3190 deletions

diff --git a/config-db/OpenSLX/ConfigDB.pm b/config-db/OpenSLX/ConfigDB.pm
deleted file mode 100644
index 89011246..00000000
--- a/config-db/OpenSLX/ConfigDB.pm
+++ /dev/null
@@ -1,3190 +0,0 @@
-# Copyright (c) 2006, 2007 - OpenSLX GmbH
-#
-# This program is free software distributed under the GPL version 2.
-# See http://openslx.org/COPYING
-#
-# If you have any feedback please consult http://openslx.org/feedback and
-# send your suggestions, praise, or complaints to feedback@openslx.org
-#
-# General information about OpenSLX can be found at http://openslx.org/
-# -----------------------------------------------------------------------------
-package OpenSLX::ConfigDB;
-
-use strict;
-use warnings;
-
-our (@ISA, @EXPORT_OK, %EXPORT_TAGS, $VERSION);
-$VERSION = 1;    # API-version
-
-use Clone qw(clone);
-use File::Basename;
-
-use Exporter;
-@ISA = qw(Exporter);
-
-=pod
-
-=head1 NAME
-
-OpenSLX::ConfigDB - the configuration database API class for OpenSLX
-
-=head1 SYNOPSIS
-
-  use OpenSLX::ConfigDB;
-
-  openslxInit();
-
-  my $openslxDB = OpenSLX::ConfigDB->new();
-  $openslxDB->connect();
-
-  # fetch a client by name:
-  my $defaultClient = $openslxDB->fetchClientByFilter({'name' => '<<<default>>>'})
-
-  # fetch all systems:
-  my @systems = $openslxDB->fetchSystemByFilter();
-
-=head1 DESCRIPTION
-
-This class defines the OpenSLX API to the config database (the data layer to
-the outside world).
-
-The ConfigDB interface contains of five different parts:
-
-=over
-
-=item - L<basic methods> (connection handling)
-
-=item - L<data access methods> (getting data)
-
-=item - L<data manipulation methods> (adding, removing and changing data)
-
-=item - L<data aggregation methods> (getting info about the resulting
-configurations after mixing individual client-, group- and system-
-configurations).
-
-=item - L<suppport functions> (useful helpers)
-
-=back
-
-=head1 Special Concepts
-
-=over
-
-=item C<Filters>
-
-A filter is a hash-ref defining the filter criteria to be applied to a database
-query. Each key of the filter corresponds to a DB column and the (hash-)value
-contains the respective column value.
-
-[At a later stage, this will be improved to support a more structured approach
-to filtering (with boolean operators and hierarchical expressions)].
-
-=back
-
-=cut
-
-my @supportExports = qw(
-  mergeAttributes pushAttributes
-  externalIDForSystem externalIDForClient externalConfigNameForClient
-  generatePlaceholderFor
-);
-
-@EXPORT_OK   = (@supportExports);
-%EXPORT_TAGS = ('support' => [@supportExports],);
-
-use OpenSLX::AttributeRoster;
-use OpenSLX::Basics;
-use OpenSLX::DBSchema;
-use OpenSLX::OSPlugin::Roster;
-use OpenSLX::Utils;
-
-=head1 Methods
-
-=head2 Basic Methods
-
-=over
-
-=cut
-
-=item C<new()>
-
-Returns an object representing a database handle to the config database.
-
-=cut
-
-sub new
-{
-    my $class = shift;
-
-    my $self = {
-        'db-schema' => OpenSLX::DBSchema->new,
-    };
-
-    return bless $self, $class;
-}
-
-=item C<connect()>
-
-Tries to establish a connection to the database specified via the db-...
-settings.
-The global configuration hash C<%openslxConfig> contains further info about the
-requested connection. When implementing this method, you may have to look at
-the following entries in order to find out which database to connect to:
-
-=over
-
-=item C<$openslxConfig{'db-spec'}>
-
-Full specification of database, a special string defining the
-precise database to connect to (this allows connecting to a database
-that requires specifications which aren't cared for by the existing
-C<%config>-entries).
-
-=item C<$openslxConfig{'db-name'}>
-
-The precise name of the database that should be connected (defaults to 'openslx').
-
-=back
-
-=cut
-
-sub connect        ## no critic (ProhibitBuiltinHomonyms)
-{
-    my $self     = shift;
-    my $dbParams = shift;   # hash-ref with any additional info that might be 
-                            # required by specific metadb-module (not used yet)
-
-    my $dbType = $openslxConfig{'db-type'};
-        # name of underlying database module...
-
-    my $dbModuleName = "OpenSLX/MetaDB/$dbType.pm";
-    my $dbModule = "OpenSLX::MetaDB::$dbType";
-    unless (eval { require $dbModuleName } ) {
-        if ($! == 2) {
-            die _tr(
-                "Unable to load DB-module <%s>\nthat database type is not supported (yet?)\n",
-                $dbModuleName
-            );
-        } else {
-            die _tr("Unable to load DB-module <%s> (%s)\n", $dbModuleName, $@);
-        }
-    }
-    my $metaDB = $dbModule->new();
-    if (!$metaDB->connect($dbParams)) {
-        warn _tr("Unable to connect to DB-module <%s>\n%s", $dbModuleName, $@);
-        warn _tr("These DB-modules seem to work ok:");
-        foreach my $dbMod ('mysql', 'SQLite') {
-            my $fullDbModName = "DBD/$dbMod.pm";
-            if (eval { require $fullDbModName }) {
-                vlog(0, "\t$dbMod\n");
-            }
-        }
-        die _tr(
-            'Please use slxsettings if you want to switch to another db-type.'
-        );
-    }
-
-    $self->{'db-type'} = $dbType;
-    $self->{'meta-db'} = $metaDB;
-
-    $self->{'db-schema'}->checkAndUpgradeDBSchemaIfNecessary($self)
-        or die _tr('unable to check/update DB schema!');
-    
-    # check if any attributes or plugins have been added/removed since 
-    # last DB-session and bring the DB up-to-date, if so
-    my $pluginInfoHashVal 
-        = OpenSLX::AttributeRoster->computeMD5HashOverAllAttrs();
-    my $pluginInfoHashValInDB = $metaDB->schemaFetchPluginInfoHashVal() || '';
-    vlog(1, "plugin-info-hashes: $pluginInfoHashVal <=> $pluginInfoHashValInDB");
-    if ($pluginInfoHashValInDB ne $pluginInfoHashVal) {
-        $self->cleanupAnyInconsistencies();
-        return if !$metaDB->schemaSetPluginInfoHashVal($pluginInfoHashVal);
-    }
-    
-    return 1;
-}
-
-=item C<disconnect()>
-
-Tears down the connection to the database and cleans up.
-
-=cut
-
-sub disconnect
-{
-    my $self = shift;
-
-    $self->{'meta-db'}->disconnect();
-
-    return 1;
-}
-
-=item C<startTransaction()>
-
-Opens a database transaction - most useful if you want to make sure a couple of 
-changes apply as a whole or not at all.
-
-=cut
-
-sub startTransaction
-{
-    my $self = shift;
-
-    $self->{'meta-db'}->startTransaction();
-
-    return 1;
-}
-
-=item C<commitTransaction()>
-
-Commits a database transaction - so all changes done inside of this transaction 
-will be applied to the database.
-
-=cut
-
-sub commitTransaction
-{
-    my $self = shift;
-
-    $self->{'meta-db'}->commitTransaction();
-
-    return 1;
-}
-
-=item C<rollbackTransaction()>
-
-Revokes a database transaction - so all changes done inside of this transaction 
-will be undone.
-
-=cut
-
-sub rollbackTransaction
-{
-    my $self = shift;
-
-    $self->{'meta-db'}->rollbackTransaction();
-
-    return 1;
-}
-
-=item C<cleanupAnyInconsistencies()>
-
-Looks for any inconsistencies (stale references, references to non-existing
-plugins, ...) and removes them from the DB.
-
-=cut
-
-sub cleanupAnyInconsistencies
-{
-    my $self = shift;
-
-    $self->synchronizeAttributesWithDB();
-
-    return if !$self->_removeStaleSystemAttributes();
-    return if !$self->_removeStaleGroupAttributes();
-    return if !$self->_removeStaleClientAttributes();
-    return if !$self->_removeStaleVendorOSAttributes();
-
-    return 1;
-}
-
-=item C<synchronizeAttributesWithDB()>
-
-Makes sure that all known attributes are referenced by the default system
-(and no unknown ones).
-
-Additionally, all systems, groups and clients can be checked and get their
-stale attributes removed, too.
-
-=cut
-
-sub synchronizeAttributesWithDB
-{
-    my $self = shift;
-
-    my $defaultSystem = $self->fetchSystemByID(0);
-    return if !$defaultSystem;
-
-    # fetch all known attributes from attribute roster and merge these 
-    # into the existing attributes of the default system and client
-    my $attrInfo = OpenSLX::AttributeRoster->getAttrInfo();
-
-    # add new system attributes to default system
-    my @newSystemAttrs
-        =   grep { 
-                $attrInfo->{$_}->{applies_to_systems}
-                && !exists $defaultSystem->{attrs}->{$_} 
-            } keys %{$attrInfo};
-    foreach my $attr (@newSystemAttrs) {
-        $defaultSystem->{attrs}->{$attr} = $attrInfo->{$attr}->{default};
-    }
-    
-    # remove unknown system attributes from default system
-    my @unknownSystemAttrs
-        =   grep { 
-                !exists $attrInfo->{$_}
-                || !$attrInfo->{$_}->{applies_to_systems}
-            } keys %{$defaultSystem->{attrs}};
-    foreach my $unknownAttr (@unknownSystemAttrs) {
-        delete $defaultSystem->{attrs}->{$unknownAttr};
-    }
-    
-    # now write back the updated default system if necessary
-    if (@newSystemAttrs || @unknownSystemAttrs) {
-        return if !$self->changeSystem(0, $defaultSystem);
-    }
-    
-    my $defaultClient = $self->fetchClientByID(0);
-    return if !$defaultClient;
-
-    # add new client attributes to default client (deal only with
-    # attributes that are client-only)
-    my @newClientAttrs
-        =   grep { 
-                $attrInfo->{$_}->{applies_to_clients}
-                && !$attrInfo->{$_}->{applies_to_systems}
-                && !exists $defaultClient->{attrs}->{$_} 
-            } keys %{$attrInfo};
-    foreach my $attr (@newClientAttrs) {
-        $defaultClient->{attrs}->{$attr} = $attrInfo->{$attr}->{default};
-    }
-    
-    # remove unknown client attributes from default client (deal only with
-    # attributes that are client-only)
-    my @unknownClientAttrs
-        =   grep { 
-                !exists $attrInfo->{$_}
-                || !$attrInfo->{$_}->{applies_to_clients}
-                || $attrInfo->{$_}->{applies_to_systems}
-            } keys %{$defaultClient->{attrs}};
-    foreach my $unknownAttr (@unknownClientAttrs) {
-        delete $defaultClient->{attrs}->{$unknownAttr};
-    }
-    
-    # now write back the updated default client if necessary
-    if (@newClientAttrs || @unknownClientAttrs) {
-        return if !$self->changeClient(0, $defaultClient);
-    }
-    
-    return 1;
-}
-
-=item C<_removeStaleSystemAttributes()>
-
-Removes any stale attributes from every system.
-
-=cut
-
-sub _removeStaleSystemAttributes
-{
-    my $self = shift;
-
-    my $attrInfo = OpenSLX::AttributeRoster->getAttrInfo();
-
-    my @systems = $self->fetchSystemByFilter();
-    foreach my $system (@systems) {
-        my @unknownAttrs 
-            = grep { !exists $attrInfo->{$_} } keys %{$system->{attrs}};
-        if (@unknownAttrs) {
-            foreach my $unknownAttr (@unknownAttrs) {
-                delete $system->{attrs}->{$unknownAttr};
-            }
-            return if !$self->changeSystem($system->{id}, $system);
-        }
-    }
-
-    return 1;
-}
-
-=item C<_removeStaleGroupAttributes()>
-
-Removes any stale attributes from every group.
-
-=cut
-
-sub _removeStaleGroupAttributes
-{
-    my $self = shift;
-
-    my $attrInfo = OpenSLX::AttributeRoster->getAttrInfo();
-
-    my @groups = $self->fetchGroupByFilter();
-    foreach my $group (@groups) {
-        my @unknownAttrs 
-            = grep { !exists $attrInfo->{$_} } keys %{$group->{attrs}};
-        if (@unknownAttrs) {
-            foreach my $unknownAttr (@unknownAttrs) {
-                delete $group->{attrs}->{$unknownAttr};
-            }
-            return if !$self->changeGroup($group->{id}, $group);
-        }
-    }
-
-    return 1;
-}
-
-=item C<_removeStaleClientAttributes()>
-
-Removes any stale attributes from every client.
-
-=cut
-
-sub _removeStaleClientAttributes
-{
-    my $self = shift;
-
-    my $attrInfo = OpenSLX::AttributeRoster->getAttrInfo();
-
-    my @clients = $self->fetchClientByFilter();
-    foreach my $client (@clients) {
-        my @unknownAttrs 
-            = grep { !exists $attrInfo->{$_} } keys %{$client->{attrs}};
-        if (@unknownAttrs) {
-            foreach my $unknownAttr (@unknownAttrs) {
-                delete $client->{attrs}->{$unknownAttr};
-            }
-            return if !$self->changeClient($client->{id}, $client);
-        }
-    }
-
-    return 1;
-}
-
-=item C<_removeStaleVendorOSAttributes()>
-
-Removes any stale attributes from every vendor-OS.
-
-=cut
-
-sub _removeStaleVendorOSAttributes
-{
-    my $self = shift;
-
-    my @vendorOSes = $self->fetchVendorOSByFilter();
-    foreach my $vendorOS (@vendorOSes) {
-        my @installedPlugins = $self->fetchInstalledPlugins($vendorOS->{id});
-        foreach my $plugin (@installedPlugins) {
-            my $pluginName = $plugin->{plugin_name};
-            my $attrInfo 
-                = OpenSLX::OSPlugin::Roster->getPluginAttrInfo($pluginName);
-            if ($attrInfo) {
-                my @unknownAttrs 
-                    = grep { !exists $attrInfo->{$_} } keys %{$plugin->{attrs}};
-                if (@unknownAttrs) {
-                    foreach my $unknownAttr (@unknownAttrs) {
-                        delete $plugin->{attrs}->{$unknownAttr};
-                    }
-                    return if !$self->addInstalledPlugin(
-                        $vendorOS->{id}, $pluginName, $plugin->{attrs}
-                    );
-                }
-            }
-            else {
-                $self->removeInstalledPlugin($vendorOS->{id}, $pluginName);
-            }
-        }
-    }
-
-    return 1;
-}
-
-=back
-
-=head2 Data Access Methods
-
-=over
-
-=cut
-
-=item C<getColumnsOfTable($tableName)>
-
-Returns the names of the columns of the given table.
-
-=over
-
-=item Param C<tableName>
-
-The name of the DB-table whose columns you'd like to retrieve.
-
-=item Return Value
-
-An array of column names.
-
-=back
-
-=cut
-
-sub getColumnsOfTable
-{
-    my $self      = shift;
-    my $tableName = shift;
-
-    return $self->{'db-schema'}->getColumnsOfTable($tableName);
-}
-
-=item C<fetchVendorOSByFilter([%$filter], [$resultCols])>
-
-Fetches and returns information about all vendor-OSes that match the given
-filter.
-
-=over
-
-=item Param C<filter>
-
-A hash-ref containing the filter criteria that shall be applied - default
-is no filtering. See L</"Filters"> for more info.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchVendorOSByFilter
-{
-    my $self       = shift;
-    my $filter     = shift;
-    my $resultCols = shift;
-
-    my @vendorOS 
-        = $self->{'meta-db'}->fetchVendorOSByFilter($filter, $resultCols);
-
-    return wantarray() ? @vendorOS : shift @vendorOS;
-}
-
-=item C<fetchVendorOSByID(@$ids, [$resultCols])>
-
-Fetches and returns information the vendor-OSes with the given IDs.
-
-=over
-
-=item Param C<ids>
-
-An array of the vendor-OS-IDs you are interested in.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchVendorOSByID
-{
-    my $self       = shift;
-    my $ids        = _aref(shift);
-    my $resultCols = shift;
-
-    my @vendorOS = $self->{'meta-db'}->fetchVendorOSByID($ids, $resultCols);
-
-    return wantarray() ? @vendorOS : shift @vendorOS;
-}
-
-=item C<fetchInstalledPlugins($vendorOSID)>
-
-Returns the names of all plugins that have been installed into the given
-vendor-OS.
-
-=over
-
-=item Param C<vendorOSID>
-
-The id of the vendor-OS whose plugins you are interested in
-
-=item Param C<pluginName> [Optional]
-
-The name of a specific plugin you are interested in
-
-=item Return Value
-
-An array with the plugin names.
-
-=back
-
-=cut
-
-sub fetchInstalledPlugins
-{
-    my $self       = shift;
-    my $vendorOSID = shift;
-    my $pluginName = shift;
-
-    $self->{'meta-db'}->fetchInstalledPlugins($vendorOSID, $pluginName);
-}
-
-=item C<fetchExportByFilter([%$filter], [$resultCols])>
-
-Fetches and returns information about all exports that match the given
-filter.
-
-=over
-
-=item Param C<filter>
-
-A hash-ref containing the filter criteria that shall be applied - default
-is no filtering. See L</"Filters"> for more info.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchExportByFilter
-{
-    my $self       = shift;
-    my $filter     = shift;
-    my $resultCols = shift;
-
-    my @exports = $self->{'meta-db'}->fetchExportByFilter($filter, $resultCols);
-
-    return wantarray() ? @exports : shift @exports;
-}
-
-=item C<fetchExportByID(@$ids, [$resultCols])>
-
-Fetches and returns information the exports with the given IDs.
-
-=over
-
-=item Param C<ids>
-
-An array of the export-IDs you are interested in.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchExportByID
-{
-    my $self       = shift;
-    my $ids        = _aref(shift);
-    my $resultCols = shift;
-
-    my @exports = $self->{'meta-db'}->fetchExportByID($ids, $resultCols);
-
-    return wantarray() ? @exports : shift @exports;
-}
-
-=item C<fetchExportIDsOfVendorOS($id)>
-
-Fetches the IDs of all exports that make use of the vendor-OS with the given ID.
-
-=over
-
-=item Param C<id>
-
-ID of the vendor-OS whose exports shall be returned.
-
-=item Return Value
-
-An array of system-IDs.
-
-=back
-
-=cut
-
-sub fetchExportIDsOfVendorOS
-{
-    my $self       = shift;
-    my $vendorOSID = shift;
-
-    return $self->{'meta-db'}->fetchExportIDsOfVendorOS($vendorOSID);
-}
-
-=item C<fetchGlobalInfo($id)>
-
-Fetches the global info element specified by the given ID.
-
-=over
-
-=item Param C<id>
-
-The name of the global info value you are interested in.
-
-=item Return Value
-
-The value of the requested global info.
-
-=back
-
-=cut
-
-sub fetchGlobalInfo
-{
-    my $self = shift;
-    my $id   = shift;
-
-    return $self->{'meta-db'}->fetchGlobalInfo($id);
-}
-
-=item C<fetchSystemByFilter([%$filter], [$resultCols])>
-
-Fetches and returns information about all systems that match the given filter.
-
-=over
-
-=item Param C<$filter>
-
-A hash-ref containing the filter criteria that shall be applied - default
-is no filtering. See L</"Filters"> for more info.
-
-=item Param C<$resultCols> [Optional]
-
-A comma-separated list of colunm names that shall be returned. If not defined,
-all available data must be returned.
-
-=item Param C<$attrFilter> [Optional]
-
-A hash-ref containing the filter criteria that shall be applied against
-attributes.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchSystemByFilter
-{
-    my $self       = shift;
-    my $filter     = shift;
-    my $resultCols = shift;
-    my $attrFilter = shift;
-
-    my @systems = $self->{'meta-db'}->fetchSystemByFilter(
-        $filter, $resultCols, $attrFilter
-    );
-
-    # unless specific result cols have been given, we mix in the attributes
-    # of each system, too:
-    if (!defined $resultCols) {
-        foreach my $system (@systems) {
-            $system->{attrs} 
-                = $self->{'meta-db'}->fetchSystemAttrs($system->{id});
-        }
-    }
-
-    return wantarray() ? @systems : shift @systems;
-}
-
-=item C<fetchSystemByID(@$ids, [$resultCols])>
-
-Fetches and returns information the systems with the given IDs.
-
-=over
-
-=item Param C<ids>
-
-An array of the system-IDs you are interested in.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchSystemByID
-{
-    my $self       = shift;
-    my $ids        = _aref(shift);
-    my $resultCols = shift;
-
-    my @systems = $self->{'meta-db'}->fetchSystemByID($ids, $resultCols);
-    
-    # unless specific result cols have been given, we mix in the attributes
-    # of each system, too:
-    if (!defined $resultCols) {
-        foreach my $system (@systems) {
-            $system->{attrs} 
-                = $self->{'meta-db'}->fetchSystemAttrs($system->{id});
-        }
-    }
-
-    return wantarray() ? @systems : shift @systems;
-}
-
-=item C<fetchSystemIDsOfExport($id)>
-
-Fetches the IDs of all systems that make use of the export with the given ID.
-
-=over
-
-=item Param C<id>
-
-ID of the export whose systems shall be returned.
-
-=item Return Value
-
-An array of system-IDs.
-
-=back
-
-=cut
-
-sub fetchSystemIDsOfExport
-{
-    my $self     = shift;
-    my $exportID = shift;
-
-    return $self->{'meta-db'}->fetchSystemIDsOfExport($exportID);
-}
-
-=item C<fetchSystemIDsOfClient($id)>
-
-Fetches the IDs of all systems that are used by the client with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the client whose systems shall be returned.
-
-=item Return Value
-
-An array of system-IDs.
-
-=back
-
-=cut
-
-sub fetchSystemIDsOfClient
-{
-    my $self     = shift;
-    my $clientID = shift;
-
-    return $self->{'meta-db'}->fetchSystemIDsOfClient($clientID);
-}
-
-=item C<fetchSystemIDsOfGroup($id)>
-
-Fetches the IDs of all systems that are part of the group with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the group whose systems shall be returned.
-
-=item Return Value
-
-An array of system-IDs.
-
-=back
-
-=cut
-
-sub fetchSystemIDsOfGroup
-{
-    my $self    = shift;
-    my $groupID = shift;
-
-    return $self->{'meta-db'}->fetchSystemIDsOfGroup($groupID);
-}
-
-=item C<fetchClientByFilter([%$filter], [$resultCols])>
-
-Fetches and returns information about all clients that match the given filter.
-
-=over
-
-=item Param C<$filter>
-
-A hash-ref containing the filter criteria that shall be applied - default
-is no filtering. See L</"Filters"> for more info.
-
-=item Param C<$resultCols> [Optional]
-
-A comma-separated list of colunm names that shall be returned. If not defined,
-all available data must be returned.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchClientByFilter
-{
-    my $self       = shift;
-    my $filter     = shift;
-    my $resultCols = shift;
-    my $attrFilter = shift;
-
-    my @clients = $self->{'meta-db'}->fetchClientByFilter(
-        $filter, $resultCols, $attrFilter
-    );
-
-    # unless specific result cols have been given, we mix in the attributes
-    # of each client, too:
-    if (!defined $resultCols) {
-        foreach my $client (@clients) {
-            $client->{attrs} 
-                = $self->{'meta-db'}->fetchClientAttrs($client->{id});
-        }
-    }
-
-    return wantarray() ? @clients : shift @clients;
-}
-
-=item C<fetchClientByID(@$ids, [$resultCols])>
-
-Fetches and returns information the clients with the given IDs.
-
-=over
-
-=item Param C<ids>
-
-An array of the client-IDs you are interested in.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchClientByID
-{
-    my $self       = shift;
-    my $ids        = _aref(shift);
-    my $resultCols = shift;
-
-    my @clients = $self->{'meta-db'}->fetchClientByID($ids, $resultCols);
-
-    # unless specific result cols have been given, we mix in the attributes
-    # of each client, too:
-    if (!defined $resultCols) {
-        foreach my $client (@clients) {
-            $client->{attrs} 
-                = $self->{'meta-db'}->fetchClientAttrs($client->{id});
-        }
-    }
-
-    return wantarray() ? @clients : shift @clients;
-}
-
-=item C<fetchClientIDsOfSystem($id)>
-
-Fetches the IDs of all clients that make use of the system with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the system whose clients shall be returned.
-
-=item Return Value
-
-An array of client-IDs.
-
-=back
-
-=cut
-
-sub fetchClientIDsOfSystem
-{
-    my $self     = shift;
-    my $systemID = shift;
-
-    return $self->{'meta-db'}->fetchClientIDsOfSystem($systemID);
-}
-
-=item C<fetchClientIDsOfGroup($id)>
-
-Fetches the IDs of all clients that are part of the group with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the group whose clients shall be returned.
-
-=item Return Value
-
-An array of client-IDs.
-
-=back
-
-=cut
-
-sub fetchClientIDsOfGroup
-{
-    my $self    = shift;
-    my $groupID = shift;
-
-    return $self->{'meta-db'}->fetchClientIDsOfGroup($groupID);
-}
-
-=item C<fetchGroupByFilter([%$filter], [$resultCols])>
-
-Fetches and returns information about all groups that match the given filter.
-
-=over
-
-=item Param C<$filter>
-
-A hash-ref containing the filter criteria that shall be applied - default
-is no filtering. See L</"Filters"> for more info.
-
-=item Param C<$resultCols> [Optional]
-
-A comma-separated list of colunm names that shall be returned. If not defined,
-all available data must be returned.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchGroupByFilter
-{
-    my $self       = shift;
-    my $filter     = shift;
-    my $resultCols = shift;
-    my $attrFilter = shift;
-
-    my @groups = $self->{'meta-db'}->fetchGroupByFilter(
-        $filter, $resultCols, $attrFilter
-    );
-
-    # unless specific result cols have been given, we mix in the attributes
-    # of each group, too:
-    if (!defined $resultCols) {
-        foreach my $group (@groups) {
-            $group->{attrs} 
-                = $self->{'meta-db'}->fetchGroupAttrs($group->{id});
-        }
-    }
-
-    return wantarray() ? @groups : shift @groups;
-}
-
-=item C<fetchGroupByID(@$ids, [$resultCols])>
-
-Fetches and returns information the groups with the given IDs.
-
-=over
-
-=item Param C<ids>
-
-An array of the group-IDs you are interested in.
-
-=item Param C<resultCols>
-
-A string listing the columns that shall be returned - default is all columns.
-
-=item Return Value
-
-An array of hash-refs containing the resulting data rows.
-
-=back
-
-=cut
-
-sub fetchGroupByID
-{
-    my $self       = shift;
-    my $ids        = _aref(shift);
-    my $resultCols = shift;
-
-    my @groups = $self->{'meta-db'}->fetchGroupByID($ids, $resultCols);
-
-    # unless specific result cols have been given, we mix in the attributes
-    # of each group, too:
-    if (!defined $resultCols) {
-        foreach my $group (@groups) {
-            $group->{attrs} 
-                = $self->{'meta-db'}->fetchGroupAttrs($group->{id});
-        }
-    }
-
-    return wantarray() ? @groups : shift @groups;
-}
-
-=item C<fetchGroupIDsOfSystem($id)>
-
-Fetches the IDs of all groups that contain the system with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the system whose groups shall be returned.
-
-=item Return Value
-
-An array of client-IDs.
-
-=back
-
-=cut
-
-sub fetchGroupIDsOfSystem
-{
-    my $self     = shift;
-    my $systemID = shift;
-
-    return $self->{'meta-db'}->fetchGroupIDsOfSystem($systemID);
-}
-
-=item C<fetchGroupIDsOfClient($id)>
-
-Fetches the IDs of all groups that contain the client with the given
-ID.
-
-=over
-
-=item Param C<id>
-
-ID of the client whose groups shall be returned.
-
-=item Return Value
-
-An array of client-IDs.
-
-=back
-
-=cut
-
-sub fetchGroupIDsOfClient
-{
-    my $self     = shift;
-    my $clientID = shift;
-
-    return $self->{'meta-db'}->fetchGroupIDsOfClient($clientID);
-}
-
-=back
-
-=head2 Data Manipulation Methods
-
-=over
-
-=item C<addVendorOS(@$valRows)>
-
-Adds one or more vendor-OS to the database.
-
-=over
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the data of the new vendor-OS(es).
-
-=item Return Value
-
-The IDs of the new vendor-OS(es), C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addVendorOS
-{
-    my $self    = shift;
-    my $valRows = _aref(shift);
-
-    _checkCols($valRows, 'vendor_os', 'name');
-
-    my @IDs = $self->{'meta-db'}->addVendorOS($valRows);
-    return wantarray() ? @IDs : $IDs[0];
-}
-
-=item C<removeVendorOS(@$vendorOSIDs)>
-
-Removes one or more vendor-OS from the database.
-
-=over
-
-=item Param C<vendorOSIDs>
-
-An array-ref containing the IDs of the vendor-OSes that shall be removed.
-
-=item Return Value
-
-C<1> if the vendorOS(es) could be removed, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeVendorOS
-{
-    my $self        = shift;
-    my $vendorOSIDs = _aref(shift);
-
-    # drop all installed plugins before removing the vendor-OS
-    foreach my $vendorOSID (@$vendorOSIDs) {
-        my @installedPlugins 
-            = $self->{'meta-db'}->fetchInstalledPlugins($vendorOSID);
-        foreach my $plugin (@installedPlugins) {
-            my $pluginName = $plugin->{plugin_name};
-            $self->{'meta-db'}->removeInstalledPlugin($vendorOSID, $pluginName);
-        }
-    }
-    return $self->{'meta-db'}->removeVendorOS($vendorOSIDs);
-}
-
-=item C<changeVendorOS(@$vendorOSIDs, @$valRows)>
-
-Changes the data of one or more vendor-OS.
-
-=over
-
-=item Param C<vendorOSIDs>
-
-An array-ref containing the IDs of the vendor-OSes that shall be changed.
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the new data for the vendor-OS(es).
-
-=item Return Value
-
-C<1> if the vendorOS(es) could be changed, C<undef> if not.
-
-=back
-
-=cut
-
-sub changeVendorOS
-{
-    my $self        = shift;
-    my $vendorOSIDs = _aref(shift);
-    my $valRows     = _aref(shift);
-
-    return $self->{'meta-db'}->changeVendorOS($vendorOSIDs, $valRows);
-}
-
-=item C<addInstalledPlugin($vendorOSID, $pluginName)>
-
-Adds a freshly installed plugin to a vendor-OS.
-
-=over
-
-=item Param C<vendorOSID>
-
-The id of the vendor-OS the given plugin has been installed into
-
-=item Param C<pluginName>
-
-The name of the plugin that has been installed
-
-=item Return Value
-
-The ID of the new reference entry, C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addInstalledPlugin
-{
-    my $self        = shift;
-    my $vendorOSID  = shift;
-    my $pluginName  = shift;
-    my $pluginAttrs = shift || {};
-
-    return $self->{'meta-db'}->addInstalledPlugin(
-        $vendorOSID, $pluginName, $pluginAttrs
-    );
-}
-
-=item C<removeInstalledPlugin($vendorOSID, $pluginName)>
-
-Removes a uninstalled plugin for a vendor-OS.
-
-=over
-
-=item Param C<vendorOSID>
-
-The id of the vendor-OS the given plugin has been uninstalled from
-
-=item Param C<pluginName>
-
-The name of the plugin that has been uninstalled
-
-=item Return Value
-
-1 if it worked, C<undef> if it didn't.
-
-=back
-
-=cut
-
-sub removeInstalledPlugin
-{
-    my $self       = shift;
-    my $vendorOSID = shift;
-    my $pluginName = shift;
-
-    return $self->{'meta-db'}->removeInstalledPlugin($vendorOSID, $pluginName);
-}
-
-=item C<addExport(@$valRows)>
-
-Adds one or more export to the database.
-
-=over
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the data of the new export(s).
-
-=item Return Value
-
-The IDs of the new export(s), C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addExport
-{
-    my $self    = shift;
-    my $valRows = _aref(shift);
-
-    _checkCols($valRows, 'export', qw(name vendor_os_id type));
-
-    my @IDs = $self->{'meta-db'}->addExport($valRows);
-    return wantarray() ? @IDs : $IDs[0];
-}
-
-=item C<removeExport(@$exportIDs)>
-
-Removes one or more export from the database.
-
-=over
-
-=item Param C<exportIDs>
-
-An array-ref containing the IDs of the exports that shall be removed.
-
-=item Return Value
-
-C<1> if the export(s) could be removed, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeExport
-{
-    my $self      = shift;
-    my $exportIDs = _aref(shift);
-
-    return $self->{'meta-db'}->removeExport($exportIDs);
-}
-
-=item C<changeExport(@$exportIDs, @$valRows)>
-
-Changes the data of one or more export.
-
-=over
-
-=item Param C<vendorOSIDs>
-
-An array-ref containing the IDs of the exports that shall be changed.
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the new data for the export(s).
-
-=item Return Value
-
-C<1> if the export(s) could be changed, C<undef> if not.
-
-=back
-
-=cut
-
-sub changeExport
-{
-    my $self      = shift;
-    my $exportIDs = _aref(shift);
-    my $valRows   = _aref(shift);
-
-    return $self->{'meta-db'}->changeExport($exportIDs, $valRows);
-}
-
-=item C<incrementGlobalCounter($counterName)>
-
-Increments the global counter of the given name and returns the *old* value.
-
-=over
-
-=item Param C<counterName>
-
-The name of the global counter that shall be bumped.
-
-=item Return Value
-
-The value the global counter had before it was incremented.
-
-=back
-
-=cut
-
-sub incrementGlobalCounter
-{
-    my $self        = shift;
-    my $counterName = shift;
-
-    $self->startTransaction();
-    my $value = $self->fetchGlobalInfo($counterName);
-    return unless defined $value;
-    my $newValue = $value + 1;
-    $self->changeGlobalInfo($counterName, $newValue);
-    $self->commitTransaction();
-
-    return $value;
-}
-
-=item C<changeGlobalInfo($id, $value)>
-
-Sets the global info element specified by the given ID to the given value.
-
-=over
-
-=item Param C<id>
-
-The ID specifying the global info you'd like to change.
-
-=item Param C<value>
-
-The new value for the global info element.
-
-=item Return Value
-
-The value the global counter had before it was incremented.
-
-=back
-
-=cut
-
-sub changeGlobalInfo
-{
-    my $self  = shift;
-    my $id    = shift;
-    my $value = shift;
-
-    return if !defined $self->{'meta-db'}->fetchGlobalInfo($id);
-
-    return $self->{'meta-db'}->changeGlobalInfo($id, $value);
-}
-
-=item C<addSystem(@$valRows)>
-
-Adds one or more systems to the database.
-
-=over
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the data of the new system(s).
-
-=item Return Value
-
-The IDs of the new system(s), C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addSystem
-{
-    my $self      = shift;
-    my $inValRows = _aref(shift);
-
-    _checkCols($inValRows, 'system', qw(name export_id));
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    foreach my $valRow (@$valRows) {
-        if (!$valRow->{kernel}) {
-            $valRow->{kernel} = 'vmlinuz';
-            vlog(
-                1,
-                _tr(
-                    "setting kernel of system '%s' to 'vmlinuz'!",
-                    $valRow->{name}
-                )
-            );
-        }
-        if (!$valRow->{label}) {
-            $valRow->{label} = $valRow->{name};
-        }
-    }
-
-    my @IDs = $self->{'meta-db'}->addSystem($valRows, $attrValRows);
-    return wantarray() ? @IDs : $IDs[0];
-}
-
-=item C<removeSystem(@$systemIDs)>
-
-Removes one or more systems from the database.
-
-=over
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be removed.
-
-=item Return Value
-
-C<1> if the system(s) could be removed, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeSystem
-{
-    my $self      = shift;
-    my $systemIDs = _aref(shift);
-
-    foreach my $system (@$systemIDs) {
-        $self->setGroupIDsOfSystem($system);
-        $self->setClientIDsOfSystem($system);
-    }
-
-    return $self->{'meta-db'}->removeSystem($systemIDs);
-}
-
-=item C<changeSystem(@$systemIDs, @$valRows)>
-
-Changes the data of one or more systems.
-
-=over
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be changed.
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the new data for the system(s).
-
-=item Return Value
-
-C<1> if the system(s) could be changed, C<undef> if not.
-
-=back
-
-=cut
-
-sub changeSystem
-{
-    my $self      = shift;
-    my $systemIDs = _aref(shift);
-    my $inValRows = _aref(shift);
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    return $self->{'meta-db'}->changeSystem($systemIDs, $valRows, $attrValRows);
-}
-
-#=item C<setSystemAttr($systemID, $attrName, $attrValue)>
-#
-#Sets a value for an attribute of the given system. If the system already
-#has a value for this attribute, it will be overwritten.
-#
-#=over
-#
-#=item Param C<systemID>
-#
-#The ID of the system whose attribute shall be changed.
-#
-#=item Param C<attrName>
-#
-#The name of the attribute to change.
-#
-#=item Param C<attrValue>
-#
-#The new value for the attribute.
-#
-#=item Return Value
-#
-#C<1> if the attribute could be set, C<undef> if not.
-#
-#=back
-#
-#=cut
-#
-#sub setSystemAttr
-#{
-#    my $self      = shift;
-#    my $systemID  = shift;
-#    my $attrName  = shift;
-#    my $attrValue = shift;
-#
-#    return $self->{'meta-db'}->setSystemAttr($systemID, $attrName, $attrValue);
-#}
-
-=item C<setClientIDsOfSystem($systemID, @$clientIDs)>
-
-Specifies all clients that should offer the given system for booting.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system whose clients you'd like to specify.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be connected to the
-system.
-
-=item Return Value
-
-C<1> if the system/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setClientIDsOfSystem
-{
-    my $self      = shift;
-    my $systemID  = shift;
-    my $clientIDs = _aref(shift);
-
-    # associating a client to the default system makes no sense
-    return 0 if $systemID == 0;
-
-    my @uniqueClientIDs = _unique(@$clientIDs);
-
-    return $self->{'meta-db'}->setClientIDsOfSystem(
-        $systemID, \@uniqueClientIDs
-    );
-}
-
-=item C<addClientIDsToSystem($systemID, @$clientIDs)>
-
-Add one or more clients to the set that should offer the given system for booting.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system that you wish to add the clients to.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the new clients that shall be added to the
-system.
-
-=item Return Value
-
-C<1> if the system/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addClientIDsToSystem
-{
-    my $self         = shift;
-    my $systemID     = shift;
-    my $newClientIDs = _aref(shift);
-
-    my @clientIDs = $self->{'meta-db'}->fetchClientIDsOfSystem($systemID);
-    push @clientIDs, @$newClientIDs;
-
-    return $self->setClientIDsOfSystem($systemID, \@clientIDs);
-}
-
-=item C<removeClientIDsFromSystem($systemID, @$clientIDs)>
-
-Removes the connection between the given clients and the given system.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system you'd like to remove groups from.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be removed from the
-system.
-
-=item Return Value
-
-C<1> if the system/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeClientIDsFromSystem
-{
-    my $self             = shift;
-    my $systemID         = shift;
-    my $removedClientIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$removedClientIDs} = ();
-    my @clientIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchClientIDsOfSystem($systemID);
-
-    return $self->setClientIDsOfSystem($systemID, \@clientIDs);
-}
-
-=item C<setGroupIDsOfSystem($systemID, @$groupIDs)>
-
-Specifies all groups that should offer the given system for booting.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system whose groups you'd like to specify.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be connected to the
-system.
-
-=item Return Value
-
-C<1> if the system/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setGroupIDsOfSystem
-{
-    my $self     = shift;
-    my $systemID = shift;
-    my $groupIDs = _aref(shift);
-
-    # associating a group to the default system makes no sense
-    return 0 if $systemID == 0;
-
-    my @uniqueGroupIDs = _unique(@$groupIDs);
-
-    return $self->{'meta-db'}->setGroupIDsOfSystem($systemID, \@uniqueGroupIDs);
-}
-
-=item C<addGroupIDsToSystem($systemID, @$groupIDs)>
-
-Add one or more groups to the set that should offer the given system for booting.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system that you wish to add the groups to.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the new groups that shall be added to the
-system.
-
-=item Return Value
-
-C<1> if the system/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addGroupIDsToSystem
-{
-    my $self        = shift;
-    my $systemID    = shift;
-    my $newGroupIDs = _aref(shift);
-
-    my @groupIDs = $self->{'meta-db'}->fetchGroupIDsOfSystem($systemID);
-    push @groupIDs, @$newGroupIDs;
-
-    return $self->setGroupIDsOfSystem($systemID, \@groupIDs);
-}
-
-=item C<removeGroupIDsFromSystem($systemID, @$groupIDs)>
-
-Removes the connection between the given groups and the given system.
-
-=over
-
-=item Param C<systemID>
-
-The ID of the system you'd like to remove groups from.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be removed from the
-system.
-
-=item Return Value
-
-C<1> if the system/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeGroupIDsFromSystem
-{
-    my $self                = shift;
-    my $systemID            = shift;
-    my $toBeRemovedGroupIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$toBeRemovedGroupIDs} = ();
-    my @groupIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchGroupIDsOfSystem($systemID);
-
-    return $self->setGroupIDsOfSystem($systemID, \@groupIDs);
-}
-
-=item C<addClient(@$valRows)>
-
-Adds one or more clients to the database.
-
-=over
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the data of the new client(s).
-
-=item Return Value
-
-The IDs of the new client(s), C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addClient
-{
-    my $self      = shift;
-    my $inValRows = _aref(shift);
-
-    _checkCols($inValRows, 'client', qw(name mac));
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    my @IDs = $self->{'meta-db'}->addClient($valRows, $attrValRows);
-    return wantarray() ? @IDs : $IDs[0];
-}
-
-=item C<removeClient(@$clientIDs)>
-
-Removes one or more clients from the database.
-
-=over
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be removed.
-
-=item Return Value
-
-C<1> if the client(s) could be removed, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeClient
-{
-    my $self      = shift;
-    my $clientIDs = _aref(shift);
-
-    foreach my $client (@$clientIDs) {
-        $self->setGroupIDsOfClient($client);
-        $self->setSystemIDsOfClient($client);
-    }
-
-    return $self->{'meta-db'}->removeClient($clientIDs);
-}
-
-=item C<changeClient(@$clientIDs, @$valRows)>
-
-Changes the data of one or more clients.
-
-=over
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be changed.
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the new data for the client(s).
-
-=item Return Value
-
-C<1> if the client(s) could be changed, C<undef> if not.
-
-=back
-
-=cut
-
-sub changeClient
-{
-    my $self      = shift;
-    my $clientIDs = _aref(shift);
-    my $inValRows = _aref(shift);
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    return $self->{'meta-db'}->changeClient($clientIDs, $valRows, $attrValRows);
-}
-
-#=item C<setClientAttr($clientID, $attrName, $attrValue)>
-#
-#Sets a value for an attribute of the given client. If the client already
-#has a value for this attribute, it will be overwritten.
-#
-#=over
-#
-#=item Param C<clientID>
-#
-#The ID of the client whose attribute shall be changed.
-#
-#=item Param C<attrName>
-#
-#The name of the attribute to change.
-#
-#=item Param C<attrValue>
-#
-#The new value for the attribute.
-#
-#=item Return Value
-#
-#C<1> if the attribute could be set, C<undef> if not.
-#
-#=back
-#
-#=cut
-#
-#sub setClientAttr
-#{
-#    my $self      = shift;
-#    my $clientID  = shift;
-#    my $attrName  = shift;
-#    my $attrValue = shift;
-#
-#    return $self->{'meta-db'}->setClientAttr($clientID, $attrName, $attrValue);
-#}
-
-=item C<setSystemIDsOfClient($clientID, @$systemIDs)>
-
-Specifies all systems that should be offered for booting by the given client.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client whose systems you'd like to specify.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be connected to the
-client.
-
-=item Return Value
-
-C<1> if the client/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setSystemIDsOfClient
-{
-    my $self      = shift;
-    my $clientID  = shift;
-    my $systemIDs = _aref(shift);
-
-    # filter out the default system, as no client should be associated to it
-    my @uniqueSystemIDs = grep { $_ > 0; } _unique(@$systemIDs);
-
-    return $self->{'meta-db'}->setSystemIDsOfClient(
-        $clientID, \@uniqueSystemIDs
-    );
-}
-
-=item C<addSystemIDsToClient($clientID, @$systemIDs)>
-
-Adds some systems to the set that should be offered for booting by the given client.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client to which you'd like to add systems to.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the new systems that shall be added to the
-client.
-
-=item Return Value
-
-C<1> if the client/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addSystemIDsToClient
-{
-    my $self         = shift;
-    my $clientID     = shift;
-    my $newSystemIDs = _aref(shift);
-
-    my @systemIDs = $self->{'meta-db'}->fetchSystemIDsOfClient($clientID);
-    push @systemIDs, @$newSystemIDs;
-
-    return $self->setSystemIDsOfClient($clientID, \@systemIDs);
-}
-
-=item C<removeSystemIDsFromClient($clientID, @$systemIDs)>
-
-Removes some systems from the set that should be offered for booting by the given client.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client to which you'd like to remove systems from.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be removed from the
-client.
-
-=item Return Value
-
-C<1> if the client/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeSystemIDsFromClient
-{
-    my $self             = shift;
-    my $clientID         = shift;
-    my $removedSystemIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$removedSystemIDs} = ();
-    my @systemIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchSystemIDsOfClient($clientID);
-
-    return $self->setSystemIDsOfClient($clientID, \@systemIDs);
-}
-
-=item C<setGroupIDsOfClient($clientID, @$groupIDs)>
-
-Specifies all groups that the given client shall be part of.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client whose groups you'd like to specify.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that the client should be part of.
-
-=item Return Value
-
-C<1> if the client/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setGroupIDsOfClient
-{
-    my $self     = shift;
-    my $clientID = shift;
-    my $groupIDs = _aref(shift);
-
-    my @uniqueGroupIDs = _unique(@$groupIDs);
-
-    return $self->{'meta-db'}->setGroupIDsOfClient($clientID, \@uniqueGroupIDs);
-}
-
-=item C<addGroupIDsToClient($clientID, @$groupIDs)>
-
-Adds the given client to the given groups.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client that you'd like to add to the given groups.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be added to the
-client.
-
-=item Return Value
-
-C<1> if the client/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addGroupIDsToClient
-{
-    my $self        = shift;
-    my $clientID    = shift;
-    my $newGroupIDs = _aref(shift);
-
-    my @groupIDs = $self->{'meta-db'}->fetchGroupIDsOfClient($clientID);
-    push @groupIDs, @$newGroupIDs;
-
-    return $self->setGroupIDsOfClient($clientID, \@groupIDs);
-}
-
-=item C<removeGroupsIDsFromClient($clientID, @$groupIDs)>
-
-Removes the given client from the given groups.
-
-=over
-
-=item Param C<clientID>
-
-The ID of the client that you'd like to remove from the given groups.
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be removed from the
-client.
-
-=item Return Value
-
-C<1> if the client/group references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeGroupIDsFromClient
-{
-    my $self                = shift;
-    my $clientID            = shift;
-    my $toBeRemovedGroupIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$toBeRemovedGroupIDs} = ();
-    my @groupIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchGroupIDsOfClient($clientID);
-
-    return $self->setGroupIDsOfClient($clientID, \@groupIDs);
-}
-
-=item C<addGroup(@$valRows)>
-
-Adds one or more groups to the database.
-
-=over
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the data of the new group(s).
-
-=item Return Value
-
-The IDs of the new group(s), C<undef> if the creation failed.
-
-=back
-
-=cut
-
-sub addGroup
-{
-    my $self      = shift;
-    my $inValRows = _aref(shift);
-
-    _checkCols($inValRows, 'group', qw(name));
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    foreach my $valRow (@$valRows) {
-        if (!defined $valRow->{priority}) {
-            $valRow->{priority} = '50';
-        }
-    }
-    my @IDs = $self->{'meta-db'}->addGroup($valRows, $attrValRows);
-    return wantarray() ? @IDs : $IDs[0];
-}
-
-=item C<removeGroup(@$groupIDs)>
-
-Removes one or more groups from the database.
-
-=over
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be removed.
-
-=item Return Value
-
-C<1> if the group(s) could be removed, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeGroup
-{
-    my $self     = shift;
-    my $groupIDs = _aref(shift);
-
-    foreach my $group (@$groupIDs) {
-        $self->setSystemIDsOfGroup($group, []);
-        $self->setClientIDsOfGroup($group, []);
-    }
-
-    return $self->{'meta-db'}->removeGroup($groupIDs);
-}
-
-#=item C<setGroupAttr($groupID, $attrName, $attrValue)>
-#
-#Sets a value for an attribute of the given group. If the group already
-#has a value for this attribute, it will be overwritten.
-#
-#=over
-#
-#=item Param C<groupID>
-#
-#The ID of the group whose attribute shall be changed.
-#
-#=item Param C<attrName>
-#
-#The name of the attribute to change.
-#
-#=item Param C<attrValue>
-#
-#The new value for the attribute.
-#
-#=item Return Value
-#
-#C<1> if the attribute could be set, C<undef> if not.
-#
-#=back
-#
-#=cut
-#
-#sub setGroupAttr
-#{
-#    my $self      = shift;
-#    my $groupID  = shift;
-#    my $attrName  = shift;
-#    my $attrValue = shift;
-#
-#    return $self->{'meta-db'}->setGroupAttr($groupID, $attrName, $attrValue);
-#}
-
-=item C<changeGroup(@$groupIDs, @$valRows)>
-
-Changes the data of one or more groups.
-
-=over
-
-=item Param C<groupIDs>
-
-An array-ref containing the IDs of the groups that shall be changed.
-
-=item Param C<valRows>
-
-An array-ref containing hash-refs with the new data for the group(s).
-
-=item Return Value
-
-C<1> if the group(s) could be changed, C<undef> if not.
-
-=back
-
-=cut
-
-sub changeGroup
-{
-    my $self      = shift;
-    my $groupIDs  = _aref(shift);
-    my $inValRows = _aref(shift);
-
-    my ($valRows, $attrValRows) = _cloneAndUnhingeAttrs($inValRows);
-
-    return $self->{'meta-db'}->changeGroup($groupIDs, $valRows, $attrValRows);
-}
-
-=item C<setClientIDsOfGroup($groupID, @$clientIDs)>
-
-Specifies all clients that should be part of the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group whose clients you'd like to specify.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be part of the group.
-
-=item Return Value
-
-C<1> if the group/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setClientIDsOfGroup
-{
-    my $self      = shift;
-    my $groupID   = shift;
-    my $clientIDs = _aref(shift);
-
-    my @uniqueClientIDs = _unique(@$clientIDs);
-
-    return $self->{'meta-db'}->setClientIDsOfGroup($groupID, \@uniqueClientIDs);
-}
-
-=item C<addClientIDsToGroup($groupID, @$clientIDs)>
-
-Add some clients to the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group to which you'd like to add clients.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be added.
-
-=item Return Value
-
-C<1> if the group/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addClientIDsToGroup
-{
-    my $self         = shift;
-    my $groupID      = shift;
-    my $newClientIDs = _aref(shift);
-
-    my @clientIDs = $self->{'meta-db'}->fetchClientIDsOfGroup($groupID);
-    push @clientIDs, @$newClientIDs;
-
-    return $self->setClientIDsOfGroup($groupID, \@clientIDs);
-}
-
-=item C<removeClientIDsFromGroup($groupID, @$clientIDs)>
-
-Remove some clients from the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group from which you'd like to remove clients.
-
-=item Param C<clientIDs>
-
-An array-ref containing the IDs of the clients that shall be removed.
-
-=item Return Value
-
-C<1> if the group/client references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeClientIDsFromGroup
-{
-    my $self             = shift;
-    my $groupID          = shift;
-    my $removedClientIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$removedClientIDs} = ();
-    my @clientIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchClientIDsOfGroup($groupID);
-
-    return $self->setClientIDsOfGroup($groupID, \@clientIDs);
-}
-
-=item C<setSystemIDsOfGroup($groupID, @$systemIDs)>
-
-Specifies all systems that should be offered for booting by the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group whose systems you'd like to specify.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be connected to the
-group.
-
-=item Return Value
-
-C<1> if the group/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub setSystemIDsOfGroup
-{
-    my $self      = shift;
-    my $groupID   = shift;
-    my $systemIDs = _aref(shift);
-
-    # filter out the default system, as no group should be associated to it
-    my @uniqueSystemIDs = grep { $_ > 0; } _unique(@$systemIDs);
-
-    return $self->{'meta-db'}->setSystemIDsOfGroup($groupID, \@uniqueSystemIDs);
-}
-
-=item C<addSystemIDsToGroup($groupID, @$systemIDs)>
-
-Adds some systems to the set that should be offered for booting by the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group to which you'd like to add systems.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be added.
-
-=item Return Value
-
-C<1> if the group/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub addSystemIDsToGroup
-{
-    my $self         = shift;
-    my $groupID      = shift;
-    my $newSystemIDs = _aref(shift);
-
-    my @systemIDs = $self->{'meta-db'}->fetchSystemIDsOfGroup($groupID);
-    push @systemIDs, @$newSystemIDs;
-
-    return $self->setSystemIDsOfGroup($groupID, \@systemIDs);
-}
-
-=item C<removeSystemIDsFromGroup($groupID, @$systemIDs)>
-
-Removes some systems from the set that should be offered for booting by the given group.
-
-=over
-
-=item Param C<groupID>
-
-The ID of the group from which you'd like to remove systems.
-
-=item Param C<systemIDs>
-
-An array-ref containing the IDs of the systems that shall be removed.
-
-=item Return Value
-
-C<1> if the group/system references could be set, C<undef> if not.
-
-=back
-
-=cut
-
-sub removeSystemIDsFromGroup
-{
-    my $self             = shift;
-    my $groupID          = shift;
-    my $removedSystemIDs = _aref(shift);
-
-    my %toBeRemoved;
-    @toBeRemoved{@$removedSystemIDs} = ();
-    my @systemIDs =
-      grep { !exists $toBeRemoved{$_} }
-      $self->{'meta-db'}->fetchSystemIDsOfGroup($groupID);
-
-    return $self->setSystemIDsOfGroup($groupID, \@systemIDs);
-}
-
-=item C<emptyDatabase()>
-
-Removes all data from the database - the tables stay, but they will be empty.
-
-=over
-
-=item Return Value
-
-none
-
-=back
-
-=cut
-
-sub emptyDatabase
-{   # clears all user-data from the database
-    my $self = shift;
-
-    my @groupIDs = map { $_->{id} } $self->fetchGroupByFilter();
-    $self->removeGroup(\@groupIDs);
-
-    my @clientIDs = map { $_->{id} }
-      grep { $_->{name} ne '<<<default>>>' } $self->fetchClientByFilter();
-    $self->removeClient(\@clientIDs);
-
-    my @sysIDs = map { $_->{id} }
-      grep { $_->{name} ne '<<<default>>>' } $self->fetchSystemByFilter();
-    $self->removeSystem(\@sysIDs);
-
-    my @exportIDs = map { $_->{id} } $self->fetchExportByFilter();
-    $self->removeExport(\@exportIDs);
-
-    my @vendorOSIDs = map { $_->{id} } $self->fetchVendorOSByFilter();
-    $self->removeVendorOS(\@vendorOSIDs);
-
-    return 1;
-}
-
-=back
-
-=head2 Data Aggregation Methods
-
-=over
-
-=item C<mergeDefaultAttributesIntoSystem($system)>
-
-merges vendor-OS-specific plugin attributes and default system attributes into 
-the given system hash, and pushes the default client attributes on top of that.
-
-=over
-
-=item Param C<system>
-
-The system whose attributes shall be merged into (completed).
-
-=item Return Value
-
-none
-
-=back
-
-=cut
-
-sub mergeDefaultAttributesIntoSystem
-{
-    my $self             = shift;
-    my $system           = shift;
-    my $installedPlugins = shift;
-    my $originInfo       = shift;
-
-    # merge any attributes found in the plugins that are installed into
-    # the vendor-OS:
-    if (ref $installedPlugins eq 'ARRAY' && @$installedPlugins) {
-        for my $plugin (@$installedPlugins) {
-            mergeAttributes($system, $plugin, $originInfo, 'vendor-OS');
-        }
-
-        # the above will have merged stage1 attributes, too, so we remove
-        # these from the resulting system (as they do not apply to systems)
-        my @stage3AttrNames = OpenSLX::AttributeRoster->getStage3Attrs();
-        for my $attr (keys %{$system->{attrs}}) {
-            next if grep { $attr eq $_ } @stage3AttrNames;
-            delete $system->{attrs}->{$attr};
-        }
-    }
-
-    # merge yet unset stuff from default system
-    my $defaultSystem = $self->fetchSystemByFilter({name => '<<<default>>>'});
-    mergeAttributes($system, $defaultSystem, $originInfo, 'default-system');
-
-    # finally push the attributes specified for the default client (these
-    # overrule anything else)
-    my $defaultClient = $self->fetchClientByFilter({name => '<<<default>>>'});
-    pushAttributes($system, $defaultClient, $originInfo, 'default-client');
-
-    return 1;
-}
-
-=item C<mergeDefaultAndGroupAttributesIntoClient($client)>
-
-merges default and group configurations into the given client hash.
-
-=over
-
-=item Param C<client>
-
-The client whose attributes shall be merged into (completed).
-
-=item Return Value
-
-none
-
-=back
-
-=cut
-
-sub mergeDefaultAndGroupAttributesIntoClient
-{
-    my $self       = shift;
-    my $client     = shift;
-    my $originInfo = shift;
-
-    # step over all groups this client belongs to
-    # (ordered by priority from highest to lowest):
-    my @groupIDs = _unique(
-        $self->fetchGroupIDsOfClient(0), 
-        $self->fetchGroupIDsOfClient($client->{id})
-    );
-    my @groups
-        = sort { $a->{priority} <=> $b->{priority} }
-          $self->fetchGroupByID(\@groupIDs);
-    foreach my $group (@groups) {
-        # merge configuration from this group into the current client:
-        vlog(
-            3,
-            _tr('merging from group %d:%s...', $group->{id}, $group->{name})
-        );
-        mergeAttributes($client, $group, $originInfo, "group '$group->{name}'");
-    }
-
-    # merge configuration from default client:
-    vlog(3, _tr('merging from default client...'));
-    my $defaultClient = $self->fetchClientByFilter({name => '<<<default>>>'});
-    mergeAttributes($client, $defaultClient, $originInfo, 'default-client');
-
-    return 1;
-}
-
-=item C<aggregatedSystemIDsOfClient($client)>
-
-Returns an aggregated list of system-IDs that this client should offer for
-booting (as indicated by itself, the default client and the client's groups)
-
-=over
-
-=item Param C<client>
-
-The client whose aggregated systems you're interested in.
-
-=item Return Value
-
-A list of unqiue system-IDs.
-
-=back
-
-=cut
-
-sub aggregatedSystemIDsOfClient
-{
-    my $self   = shift;
-    my $client = shift;
-
-    # add all systems directly linked to client:
-    my @systemIDs = $self->fetchSystemIDsOfClient($client->{id});
-
-    # step over all groups this client belongs to:
-    my @groupIDs = $self->fetchGroupIDsOfClient($client->{id});
-    my @groups   = $self->fetchGroupByID(\@groupIDs);
-    foreach my $group (@groups) {
-        # add all systems that the client inherits from the current group:
-        push @systemIDs, $self->fetchSystemIDsOfGroup($group->{id});
-    }
-
-    # add all systems inherited from default client
-    my $defaultClient = $self->fetchClientByFilter({name => '<<<default>>>'});
-    push @systemIDs, $self->fetchSystemIDsOfClient($defaultClient->{id});
-
-    return _unique(@systemIDs);
-}
-
-=item C<aggregatedClientIDsOfSystem($system)>
-
-Returns an aggregated list of client-IDs that offer this system for
-booting (as indicated by itself, the default system and the system's groups)
-
-=over
-
-=item Param C<system>
-
-The system whose aggregated clients you're interested in.
-
-=item Return Value
-
-A list of unqiue client-IDs.
-
-=back
-
-=cut
-
-sub aggregatedClientIDsOfSystem
-{
-    my $self   = shift;
-    my $system = shift;
-
-    # add all clients directly linked to system:
-    my $defaultClient = $self->fetchClientByFilter({name => '<<<default>>>'});
-    my @clientIDs = $self->fetchClientIDsOfSystem($system->{id});
-
-    if (grep { $_ == $defaultClient->{id}; } @clientIDs) {
-        # add *all* client-IDs if the system is being referenced by
-        # the default client, as that means that all clients should offer
-        # this system for booting:
-        push(
-            @clientIDs,
-            map { $_->{id} } $self->fetchClientByFilter(undef, 'id')
-        );
-    }
-
-    # step over all groups this system belongs to:
-    my @groupIDs = $self->fetchGroupIDsOfSystem($system->{id});
-    my @groups   = $self->fetchGroupByID(\@groupIDs);
-    foreach my $group (@groups) {
-        # add all clients that the system inherits from the current group:
-        push @clientIDs, $self->fetchClientIDsOfGroup($group->{id});
-    }
-
-    # add all clients inherited from default system
-    my $defaultSystem = $self->fetchSystemByFilter({name => '<<<default>>>'});
-    push @clientIDs, $self->fetchClientIDsOfSystem($defaultSystem->{id});
-
-    return _unique(@clientIDs);
-}
-
-=item C<aggregatedSystemFileInfoFor($system)>
-
-Returns aggregated information about the kernel and initialramfs
-this system is using.
-
-=over
-
-=item Param C<system>
-
-The system whose aggregated info you're interested in.
-
-=item Return Value
-
-A hash containing detailled info about the vendor-OS and export used by
-this system, as well as the specific kernel-file and export-URI being used.
-
-=back
-
-=cut
-
-sub aggregatedSystemFileInfoFor
-{
-    my $self   = shift;
-    my $system = shift;
-
-    my $info = clone($system);
-
-    my $export = $self->fetchExportByID($system->{export_id});
-    if (!defined $export) {
-        die _tr(
-            "DB-problem: system '%s' references export with id=%s, but that doesn't exist!",
-            $system->{name}, $system->{export_id} || ''
-        );
-    }
-    $info->{'export'} = $export;
-
-    my $vendorOS = $self->fetchVendorOSByID($export->{vendor_os_id});
-    if (!defined $vendorOS) {
-        die _tr(
-            "DB-problem: export '%s' references vendor-OS with id=%s, but that doesn't exist!",
-            $export->{name}, $export->{vendor_os_id} || ''
-        );
-    }
-    $info->{'vendor-os'} = $vendorOS;
-    
-    my @installedPlugins = $self->fetchInstalledPlugins($vendorOS->{id});
-    $info->{'installed-plugins'} = \@installedPlugins;
-
-    # check if the specified kernel file really exists (follow links while
-    # checking) and if not, find the newest kernel file that is available.
-    my $kernelPath 
-        = "$openslxConfig{'private-path'}/stage1/$vendorOS->{name}/boot";
-    my $kernelFile = "$kernelPath/$system->{kernel}";
-    while (-l $kernelFile) {
-        $kernelFile = followLink($kernelFile);
-    }
-    if (!-e $kernelFile) {
-        # pick best kernel file available
-        my $osSetupEngine = instantiateClass("OpenSLX::OSSetup::Engine");
-        $osSetupEngine->initialize($vendorOS->{name}, 'none');
-        $kernelFile = $osSetupEngine->pickKernelFile($kernelPath);
-        warn(
-            _tr(
-                "setting kernel of system '%s' to '%s'!",
-                $info->{name}, basename($kernelFile)
-            )
-        );
-    }
-    $info->{'kernel-file'} = $kernelFile;
-
-    # auto-generate export_uri if none has been given
-    my $exportURI = $export->{'uri'} || '';
-    if ($exportURI !~ m[\w]) {
-        # instantiate OSExport engine and ask it for exportURI
-        my $osExportEngine = instantiateClass("OpenSLX::OSExport::Engine");
-        $osExportEngine->initializeFromExisting($export->{name});
-        $exportURI = $osExportEngine->generateExportURI($export, $vendorOS);
-    }
-    $info->{'export-uri'} = $exportURI;
-
-    return $info;
-}
-
-=back
-
-=head2 Support Functions
-
-=over
-
-=item C<mergeAttributes($target, $source)>
-
-Copies all attributes from source that are unset in target over (source extends target).
-
-=over
-
-=item Param C<target>
-
-The hash to be used as copy target.
-
-=item Param C<source>
-
-The hash to be used as copy source.
-
-=item Return Value
-
-none
-
-=back
-
-=cut
-
-sub mergeAttributes
-{
-    my $target     = shift;
-    my $source     = shift;
-    my $originInfo = shift;
-    my $origin     = shift;
-
-    my $sourceAttrs = $source->{attrs} || {};
-
-    $target->{attrs} ||= {};
-    my $targetAttrs = $target->{attrs};
-
-    foreach my $key (keys %$sourceAttrs) {
-        my $sourceVal = $sourceAttrs->{$key};
-        my $targetVal = $targetAttrs->{$key};
-        if (!defined $targetVal) {
-            vlog(3, _tr(
-                "merging %s (val=%s)", $key, 
-                defined $sourceVal ? $sourceVal : ''
-            ));
-            $targetAttrs->{$key} = $sourceVal;
-            if (defined $originInfo) {
-                $originInfo->{$key} = $origin;
-            }
-        }
-    }
-
-    return 1;
-}
-
-=item C<pushAttributes($target, $source)>
-
-Copies all attributes that are set in source into the target (source overrules target).
-
-=over
-
-=item Param C<target>
-
-The hash to be used as copy target.
-
-=item Param C<source>
-
-The hash to be used as copy source.
-
-=item Return Value
-
-none
-
-=back
-
-=cut
-
-sub pushAttributes
-{
-    my $target     = shift;
-    my $source     = shift;
-    my $originInfo = shift;
-    my $origin     = shift;
-
-    my $sourceAttrs = $source->{attrs} || {};
-
-    $target->{attrs} ||= {};
-    my $targetAttrs = $target->{attrs};
-
-    foreach my $key (keys %$sourceAttrs) {
-        my $sourceVal = $sourceAttrs->{$key};
-        if (defined $sourceVal) {
-            vlog(3, _tr("pushing %s (val=%s)", $key, $sourceVal));
-            $targetAttrs->{$key} = $sourceVal;
-            if (defined $originInfo) {
-                $originInfo->{$key} = $origin;
-            }
-        }
-    }
-
-    return 1;
-}
-
-=item C<externalIDForSystem($system)>
-
-Returns the given system's name as an external ID - worked into a
-state that is usable as a filename.
-
-=over
-
-=item Param C<system>
-
-The system you are interested in.
-
-=item Return Value
-
-The external ID (name) of the given system.
-
-=back
-
-=cut
-
-sub externalIDForSystem
-{
-    my $system = shift;
-
-    return "default" if $system->{name} eq '<<<default>>>';
-
-    my $name = $system->{name};
-    $name =~ tr[/][_];
-
-    return $name;
-}
-
-=item C<externalIDForClient($client)>
-
-Returns the given client's MAC as an external ID - worked into a
-state that is usable as a filename.
-
-=over
-
-=item Param C<client>
-
-The client you are interested in.
-
-=item Return Value
-
-The external ID (MAC) of the given client.
-
-=back
-
-=cut
-
-sub externalIDForClient
-{
-    my $client = shift;
-
-    return "default" if $client->{name} eq '<<<default>>>';
-
-    my $mac = lc($client->{mac});
-    # PXE seems to expect MACs being all lowercase
-    $mac =~ tr[:][-];
-
-    return "01-$mac";
-}
-
-=item C<externalConfigNameForClient($client)>
-
-Returns the given client's name as an external ID - worked into a
-state that is usable as a filename.
-
-=over
-
-=item Param C<client>
-
-The client you are interested in.
-
-=item Return Value
-
-The external name of the given client.
-
-=back
-
-=cut
-
-sub externalConfigNameForClient
-{
-    my $client = shift;
-
-    return "default" if $client->{name} eq '<<<default>>>';
-
-    my $name = $client->{name};
-    $name =~ tr[/][_];
-
-    return $name;
-}
-
-=item C<generatePlaceholdersFor($varName)>
-
-Returns the given variable as a placeholder - surrounded by '@@@' markers.
-
-=over
-
-=item Param C<varName>
-
-The variable you are interested in.
-
-=item Return Value
-
-The given variable as a placeholder string.
-
-=back
-
-=cut
-
-sub generatePlaceholderFor
-{
-    my $varName = shift;
-
-    return '@@@' . $varName . '@@@';
-}
-
-################################################################################
-### private stuff
-################################################################################
-sub _aref
-{   # transparently converts the given reference to an array-ref
-    my $ref = shift;
-
-    return [] unless defined $ref;
-    $ref = [$ref] unless ref($ref) eq 'ARRAY';
-
-    return $ref;
-}
-
-sub _unique
-{   # return given array filtered to unique elements
-    my %seenIDs;
-    return grep { !$seenIDs{$_}++; } @_;
-}
-
-sub _checkCols
-{
-    my $valRows  = shift;
-    my $table    = shift;
-    my @colNames = @_;
-
-    foreach my $valRow (@$valRows) {
-        foreach my $col (@colNames) {
-            die "need to set '$col' for $table!" if !$valRow->{$col};
-        }
-    }
-
-    return 1;
-}
-
-sub _cloneAndUnhingeAttrs
-{
-    my $inValRows = shift;
-
-    # clone data and unhinge attrs
-    my (@valRows, @attrValRows);
-    foreach my $inValRow (@$inValRows) {
-        push @attrValRows, $inValRow->{attrs};
-        my $valRow = clone($inValRow);
-        delete $valRow->{attrs};
-        push @valRows, $valRow;
-    }
-
-    return (\@valRows, \@attrValRows);
-}
-
-1;