FM / dpkg

/usr/share/dbconfig-common/dpkg

Name	Size	Mode	Actions
common	39711	0644	edit dl rm
config	23411	0644	edit dl rm
config.mysql	68	0644	edit dl rm
config.pgsql	69	0644	edit dl rm
config.sqlite3	71	0644	edit dl rm
frontend.config	61	0644	edit dl rm
frontend.config.mysql	67	0644	edit dl rm
frontend.config.pgsql	67	0644	edit dl rm
frontend.postinst	63	0644	edit dl rm
frontend.postinst.mysql	69	0644	edit dl rm
frontend.postinst.pgsql	69	0644	edit dl rm
frontend.postrm	61	0644	edit dl rm
frontend.postrm.mysql	67	0644	edit dl rm
frontend.postrm.pgsql	67	0644	edit dl rm
frontend.preinst	62	0644	edit dl rm
frontend.preinst.mysql	68	0644	edit dl rm
frontend.preinst.pgsql	68	0644	edit dl rm
frontend.prerm	60	0644	edit dl rm
frontend.prerm.mysql	66	0644	edit dl rm
frontend.prerm.pgsql	66	0644	edit dl rm
postinst	20780	0644	edit dl rm
postinst.mysql	70	0644	edit dl rm
postinst.pgsql	70	0644	edit dl rm
postinst.sqlite3	72	0644	edit dl rm
postrm	986	0644	edit dl rm
postrm.mysql	68	0644	edit dl rm
postrm.pgsql	68	0644	edit dl rm
postrm.sqlite3	70	0644	edit dl rm
preinst	431	0644	edit dl rm
preinst.mysql	69	0644	edit dl rm
preinst.pgsql	70	0644	edit dl rm
preinst.sqlite3	71	0644	edit dl rm
prerm	5825	0644	edit dl rm
prerm.mysql	67	0644	edit dl rm
prerm.pgsql	67	0644	edit dl rm
prerm.sqlite3	69	0644	edit dl rm

Edit: /usr/share/dbconfig-common/dpkg/postinst (20780B)

# -*- mode: sh -*-
###
### load up common variables and functions
###
dbc_go(){
    local importing_from_non_dbc upgrading reconfiguring f tsubstfile upgrades_pending dbc_dumpfile _dbc_asuser reinstall nowtime need_adminpw _tmp_result

. /usr/share/dbconfig-common/dpkg/common
    _dbc_debug "(postinst) dbc_go() $@"

## With dbconfig-no-thanks installed we don't need to do anything.
    if dbc_no_thanks ; then
        return 0
    fi

dbc_config "$@" || return $?
    # the maintainer has the option of telling us to not generate include files
    # for manual installs in case it changes the apps behavior to have the file
    dbc_dgi_on_manual=${dbc_dgi_on_manual:-true}

###
    ### begin main code execution
    ###
    if [ "$dbc_command" = "configure" ] || [ "$dbc_command" = "reconfigure" ];
    then
        # read in debconf responses (which are seeded from the config)
        dbc_read_package_debconf || return $?
        # and write them to file.
        dbc_write_package_config || return $?
        # finally, re-read in the configuration from this file
        dbc_read_package_config || return $?

###
        ### if they don't want our help, quit
        ###
        if [ "$dbc_install" != "true" ]; then
            # Probably a little too much in most cases, but it is possible
            # that the app password is loaded or that the user backed up after
            # providing the admin password and decided not too install in the end
            dbc_postinst_cleanup || return $?
            return 0
        fi

# export the config file if it exists, for the scripts
        if [ "$dbc_generate_include" ]; then
            # strip the leading format string for convenience
            dbc_config_include=$(echo "$dbc_generate_include" | sed -e 's/^[^:]*://')
            export dbc_generate_include
            export dbc_config_include
        fi

# find out if we're upgrading/reinstalling
        if [ "$dbc_oldversion" ]; then
            # read that little crumb left in config if we're reconfiguring
            db_get $dbc_package/internal/reconfiguring && reconfiguring="$RET"
            # if not, we're definitely upgrading
            if [ "$reconfiguring" = "false" ]; then
                upgrading="yes"
            else
                db_get $dbc_package/dbconfig-reinstall && reinstall=$RET
                # if they've said they don't want to reinstall stuff...
                if [ "$reinstall" = "false" ]; then
                    dbc_postinst_cleanup
                    return 0
                fi
            fi
        fi

# now, determine if we're upgrading from a non-dbc version.  if so,
        # there's a bunch of stuff that we do NOT want to do
        if [ "$upgrading" ] && [ "$dbc_first_version" ]; then
            if dpkg --compare-versions "$dbc_first_version" gt "$dbc_oldversion"; then
                dbc_logline "detected upgrade from previous non-dbconfig version"
                importing_from_non_dbc="true"
            fi
        fi

# don't perform the following block of code during upgrades
        if [ ! "$upgrading" ]; then
            ###
            ### first things first, see if the database client package is installed,
            ### and in case of failure provide a more sensible error message.
            ###
            dbc_detect_installed_dbtype $dbc_dbtype || \
                dbc_missing_db_package_error $dbc_dbclientpackage || return $?
            [ "$dbc_tried_again" ] && return 0

###
            ### next, if we're connecting to a local database,
            ### see if the database server package is installed,
            ### and in case of failure provide a more sensible error message.
            ###
            if [ "$dbc_method" = "unix socket" ]; then
                $dbc_db_installed_cmd || dbc_missing_db_package_error $dbc_dbpackage || \
                    return $?
                [ "$dbc_tried_again" ] && return 0
            fi

###
            ### now, create the app user account
            ###

# We check in multiple locations if we need the admin password to
            # either create the user and/or the database and/or run admin
            # scripts. We do that here in postinst instead of during config
            # because we want to avoid asking the password as much as possible
            # to enable setups where the system admin doesn't have database
            # admin rights (mostly remote db setups) and the installing package
            # doesn't need it for its scripts.

_dbc_asuser=true
            _tmp_result=0
            $dbc_checkuser_cmd || _tmp_result=$?
            _dbc_asuser=""
            if [ $_tmp_result = 0 ] ; then
                dbc_logline "$dbc_dbuser already exists and has privileges on $dbc_dbname"
            else
                dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                [ "$dbc_tried_again" ] && return 0
                $dbc_createuser_cmd || dbc_install_error "creating user" || return $?
                [ "$dbc_tried_again" ] && return 0
            fi
            
            ###
            ### If we are reconfiguring, we should empty the old database
            ### to prevent errors like "table exists".
            ###
            if [ "$reconfiguring" = "true" ]; then
                # dump the database into a temporary file
                # Note: nearly equal logic exists in prerm; probably
                # should stay in sync
                nowtime=$(date +%Y-%m-%d-%H.%M)
                if [ ! $(dirname /var/tmp/$dbc_package) = /var/tmp ]; then
                    mkdir -p $(dirname /var/tmp/$dbc_package)
                fi
                dbc_dumpfile=$(mktemp /var/tmp/$dbc_package.$dbc_dbname.$nowtime.$dbc_dbtype.XXXXXX)
                if [ ! -f $dbc_dumpfile ]; then
                    dbc_install_error "creating temporary file for database dump" || return $?
                    [ "$dbc_tried_again" ] && return 0
                fi

dbc_logline "dbconfig-common: dumping $dbc_dbtype database $dbc_dbname to $dbc_dumpfile"
                # Dump as user to enable admin password agnostic setups.
                _dbc_asuser=true
                _tmp_result=0
                $dbc_dump_cmd $dbc_dumpfile || _tmp_result=$?
                if [ $_tmp_result != 0 ] ; then
                    # If the dump fails as user, try again with dbadmin credentials (bug: #850190)
                    dbc_logline "dumping database as user failed, retrying with administrator credentials"
                    dbc_get_admin_pass || dbc_install_error "obtaining administator password" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                    _dbc_asuser=""
                    $dbc_dump_cmd $dbc_dumpfile || dbc_install_error "dumping old database" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                fi
                _dbc_asuser=""

dbc_logline "dbconfig-common: dropping old $dbc_dbtype database $dbc_dbname"
                # Drop as user if possible to enable admin password agnostic
                # setups. Currently PostgreSQL doesn't support this.
                if [ "$dbc_dbtype" = pgsql ] ; then
                    dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                    [ "$dbc_tried_again" ] && return 0
                else
                    _dbc_asuser=true
                fi
                $dbc_dropdb_cmd || dbc_install_error "dropping old database" || return $?
                [ "$dbc_tried_again" ] && return 0
                _dbc_asuser=""
            fi

###
            ### create the database
            ###

# Create database as user if possible to enable admin password
            # agnostic setups. Currently PostgreSQL doesn't support this.
            if [ "$dbc_dbtype" = pgsql ] ; then
                dbc_get_admin_pass || dbc_install_error "obtaining administator password" || return $?
                [ "$dbc_tried_again" ] && return 0
            else
                _dbc_asuser=true
            fi
            $dbc_createdb_cmd || dbc_install_error "creating database" || return $?
            [ "$dbc_tried_again" ] && return 0
            _dbc_asuser=""

###
            ### populate the database
            ###
            # sqlfile is the file to use for installing the database
            dbc_sqlfile=$dbc_share/data/$dbc_basepackage/install/$dbc_dbtype
            dbc_sqlfile_adm=$dbc_share/data/$dbc_basepackage/install-dbadmin/$dbc_dbtype
            dbc_scriptfile=$dbc_share/scripts/$dbc_basepackage/install/$dbc_dbtype
            if [ -f "$dbc_scriptfile" ]; then
                dbc_logpart "populating database via scriptfile... "
                if ! sh -c "$dbc_scriptfile $*"; then
                    dbc_error="$dbc_scriptfile exited with non-zero status\nIf the script logged anything about what went wrong,\n it can be found in /var/log/apt/term.log."
                    dbc_install_error "populating database" || return $?
                    [ "$dbc_tried_again" ] && return 0
                fi
                dbc_logline "done"
            fi

if [ -f "$dbc_sqlfile_adm" ]; then
                dbc_logpart "populating database via administrative sql... "
                if [ ! "$dbc_sql_substitutions" ]; then
                    $dbc_sqlfile_cmd $dbc_sqlfile_adm || \
                        dbc_install_error "populating database with administrative sql" || \
                        return $?                    
                    [ "$dbc_tried_again" ] && return 0
                else
                    tsubstfile=$(dbc_mktemp)
                    /usr/sbin/dbconfig-generate-include -f template -o \
                        template_infile=$dbc_sqlfile_adm $dbc_packageconfig > $tsubstfile || \
                        dbc_install_error "populating database with administrative sql" || \
                        return $? 
                    $dbc_sqlfile_cmd $tsubstfile || \
                        dbc_install_error "populating database with administrative sql" || \
                        return $?
                    rm -f $tsubstfile
                    [ "$dbc_tried_again" ] && return 0
                fi
                dbc_logline "done"
            fi

if [ -f "$dbc_sqlfile" ]; then
                dbc_logpart "populating database via sql... "
                _dbc_asuser="yes"
                if [ ! "$dbc_sql_substitutions" ]; then
                    $dbc_sqlfile_cmd $dbc_sqlfile || dbc_install_error "populating database" || \
                        return $?
                    [ "$dbc_tried_again" ] && return 0
                else
                    tsubstfile=$(dbc_mktemp)
                    /usr/sbin/dbconfig-generate-include -f template -o \
                        template_infile=$dbc_sqlfile $dbc_packageconfig > $tsubstfile || \
                        dbc_install_error "populating database" || \
                        return $?
                    $dbc_sqlfile_cmd $tsubstfile || dbc_install_error "populating database" || \
                        return $?
                    rm -f $tsubstfile
                    [ "$dbc_tried_again" ] && return 0
                fi
                _dbc_asuser=""
                dbc_logline "done"
            fi

# now that we are sure that the database has been
            # (re-)installed, we can reset the purge flag.
            db_set $dbc_package/purge false
            db_fset $dbc_package/purge seen false
        fi

# end install/reconfigure section

if [ "$importing_from_non_dbc" ]; then
            if ! $dbc_checkuser_command; then
                upgrade_error "importing dbconfig-settings" || return $?
                [ "$dbc_tried_again" ] && return 0
            fi
        fi

# begin upgrade section

if [ "$upgrading" ]; then

# Initialize need_adminpw to false, only set to true when we find
            # upgrade queries that require admin rights to avoid needless
            # querying the sysadmin
            need_adminpw="false"
            # next call may change need_adminpw
            upgrades_pending=$(_dbc_find_upgrades)

# if there are any upgrades to be applied
            if [ "$upgrades_pending" ]; then
                # ask if they want our help in the process at all
                # but only if they didn't see the question before
                # or if we are here after an error
                db_set $dbc_package/dbconfig-upgrade $dbc_upgrade
                db_input $dbc_prio_high $dbc_package/dbconfig-upgrade || true
                db_go || true
                db_get $dbc_package/dbconfig-upgrade && dbc_upgrade="$RET"

# and if they don't want our help, we'll go away
                if [ "$dbc_upgrade" != "true" ]; then return 0; fi

# get the admin password if it's needed
                if [ "$need_adminpw" != "false" ] ; then
                    if echo "$dbc_authenticated_dbtypes" | grep -q "$dbc_dbtype"; then
                        if [ ! "$dbc_frontend" ]; then
                            if [ ! "$dbc_dbtype" = "pgsql" ] || [ ! "$dbc_authmethod_admin" = "ident" ]; then
                                dbc_get_admin_pass || return $?
                            fi
                        fi
                    fi
                fi

db_input $dbc_prio_low $dbc_package/upgrade-backup || true
                db_go || true
                db_get $dbc_package/upgrade-backup && dbc_backup="$RET"

if [ "$dbc_backup" = "true" ] ; then
                    # this is the file into which upgrade backups go
                    nowtime=$(date +%Y-%m-%d-%H.%M.%S)
                    dbc_dumpfile=/var/cache/dbconfig-common/backups/${dbc_package}_${dbc_oldversion}.$dbc_dbtype_$nowtime
                    dbc_logline "creating database backup in $dbc_dumpfile"
                    # backup before we upgrade
                    _dbc_asuser="yes"
                    _tmp_result=0
                    $dbc_dump_cmd $dbc_dumpfile || _tmp_result=$?
                    if [ $_tmp_result != 0 ] ; then
                        # If the dump fails as user, try again with dbadmin credentials (bug: #850190)
                        dbc_logline "dumping database as user failed, retrying with administrator credentials"
                        dbc_get_admin_pass || dbc_upgrade_error "obtaining administator password" || \
                            return $?
                        [ "$dbc_tried_again" ] && return 0
                        _dbc_asuser=""
                        $dbc_dump_cmd $dbc_dumpfile || dbc_upgrade_error "backing up the old database" || \
                            return $?
                        [ "$dbc_tried_again" ] && return 0
                    fi
                    _dbc_asuser=""
                fi
            fi

# now perform the updates
            for f in $upgrades_pending; do
                _dbc_apply_upgrades $f || return $?
            done

fi
        # end upgrade section
    fi

# don't forget to clean up after ourselves
    dbc_postinst_cleanup
}

##
## search through the predefined upgrade directories, and return
## the versions for which *some* upgrade is available.  later for each
## upgrade version with a script we again search through the predefined
## directories to find which upgrade provides it.  it's definitely
## less efficient this way, but it's much cleaner and ensures that
## upgrades are provided in-order regardless of which methods are used.
##
_dbc_find_upgrades(){
    local f s sqldir admsqldir scriptdir upgradedirs pending sorted placed tlist
    # check for new upgrades in these three locations
    sqldir=$dbc_share/data/$dbc_basepackage/upgrade/$dbc_dbtype
    admsqldir=$dbc_share/data/$dbc_basepackage/upgrade-dbadmin/$dbc_dbtype
    scriptdir=$dbc_share/scripts/$dbc_basepackage/upgrade/$dbc_dbtype

for f in $sqldir $admsqldir $scriptdir; do
        if [ -d "$f" ]; then
            upgradedirs="${upgradedirs:+$upgradedirs }$f"
        fi
    done

if [ ! "${upgradedirs:-}" ]; then return 0; fi

for f in $(find $upgradedirs -xtype f -print0 | \
              xargs --no-run-if-empty -0 -n1 basename | sort -n | uniq); do
        if dpkg --compare-versions $dbc_oldversion lt $f; then
            pending="${pending:+$pending }$f"
        fi
    done

# for each pending update
    for f in ${pending:-}; do
        if [ -f "$admsqldir/$f" ] ; then
            # If the pending update was in the dbadmin dir we
            # need the adminpw
            need_adminpw="true"
        fi
        # if the sorted list is empty
        if [ ! "${sorted:-}" ]; then
            sorted="$f"
        else
            # a scratch list for a sorted insert of the next version
            tlist=""
            # for each already sorted version
            for s in ${sorted:-}; do
                # if we haven't already placed it
                if [ ! "${placed:-}" ]; then
                    # if the this version is less than the next sorted one
                    if dpkg --compare-versions $f lt $s; then
                        # insert it here
                        tlist="$tlist $f"
                        placed="yes"
                    fi
                fi
                tlist="$tlist $s"
            done
            # if we still haven't placed it, tack it on to the end of the list
            if [ ! "${placed:-}" ]; then
                tlist="$tlist $f"
            fi
            # and now reset the placed variable, and update the sorted list
            placed=""
            sorted="$tlist"
        fi
    done

echo $sorted
}

##
## this function applies all available upgrade scripts/sql for a specific
## version ($1).  no checking is done to make sure that the upgrade *should*
## be applied, that is assumed to have been done by _dbc_find_upgrades().
##
_dbc_apply_upgrades(){
    local f vers sqlfile admsqlfile scriptfile tsubstfile error_msg_upgrade
    _dbc_debug "_dbc_apply_upgrades() $@"
    # check for new upgrades in these three locations
    vers="$1"
    sqlfile="$dbc_share/data/$dbc_basepackage/upgrade/$dbc_dbtype/$vers"
    admsqlfile="$dbc_share/data/$dbc_basepackage/upgrade-dbadmin/$dbc_dbtype/$vers"
    scriptfile="$dbc_share/scripts/$dbc_basepackage/upgrade/$dbc_dbtype/$vers"

# now go through script updates
    if [ -f "$scriptfile" ]; then
        dbc_logline "applying upgrade script for $dbc_oldversion -> $vers"
        # XXX $*
        if ! sh -c "$scriptfile $*"; then
            dbc_error="$scriptfile exited with non-zero status"
            dbc_upgrade_error "processing $scriptfile" || return $?
            [ "$dbc_tried_again" ] && return 0
        fi
    fi

_dbc_asuser=""
    if [ -f "$admsqlfile" ]; then
        dbc_logline "applying upgrade admin sql for $dbc_oldversion -> $vers"
        tsubstfile=$admsqlfile
        error_msg_upgrade="processing $admsqlfile"
        if [ "$dbc_sql_substitutions" ]; then
            tsubstfile=$(dbc_mktemp)
            /usr/sbin/dbconfig-generate-include -f template -o template_infile=$admsqlfile \
                $dbc_packageconfig > $tsubstfile || dbc_upgrade_error "$error_msg_upgrade" || \
                return $?
            error_msg_upgrade="processing $admsqlfile (translated: $tsubstfile)"
        fi
        $dbc_sqlfile_cmd $tsubstfile || dbc_upgrade_error "$error_msg_upgrade" || return $?
        [ "$dbc_sql_substitutions" ] && rm -f $tsubstfile
        [ "$dbc_tried_again" ] && return 0
    fi

if [ -f "$sqlfile" ]; then
        _dbc_asuser="yes"
        dbc_logline "applying upgrade sql for $dbc_oldversion -> $vers"
        tsubstfile=$sqlfile
        error_msg_upgrade="processing $sqlfile"
        if [ "$dbc_sql_substitutions" ]; then
            tsubstfile=$(dbc_mktemp)
            /usr/sbin/dbconfig-generate-include -f template -o template_infile=$sqlfile \
                $dbc_packageconfig > $tsubstfile || dbc_upgrade_error "$error_msg_upgrade" || \
                return $?
            error_msg_upgrade="processing $sqlfile (translated: $tsubstfile)"
        fi
        $dbc_sqlfile_cmd $tsubstfile || dbc_upgrade_error "$error_msg_upgrade" || return $?
        [ "$dbc_sql_substitutions" ] && rm -f $tsubstfile
        [ "$dbc_tried_again" ] && return 0
        _dbc_asuser=""
    fi
}

cmd: