Centralized the install/uninstall operations for the scheduler into a set of PHP files. This will make it easier to maintain the database because 1) the code is now in a scripting language which means, for instance, that writing upgrade scripts will be easier and also allows these install scripts to use the same infrastructure and code as the storageServer, 2) it allows the developers to see the database creation all in one place 3) simplifies and speeds up the C++ code.

campcaster/src/products/scheduler/bin/campcaster-scheduler.sh

@@ -83,12 +83,12 @@ case "$mode" in
 
     'install')
         echo "Installing Campcaster scheduler database tables..."
-        $scheduler_exe -c $config_file install
+        php install.php -c $config_file
         ;;
 
     'uninstall')
         echo "Uninstalling Campcaster scheduler database tables..."
-        $scheduler_exe -c $config_file uninstall
+        php uninstall.php -c $config_file
         ;;
 
     'kill')

campcaster/src/products/scheduler/bin/install.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * @author Paul Baranowski <paul@paulbaranowski.org>
+ * @version $Revision: 2774 $
+ * @package Campcaster
+ * @subpackage Scheduler
+ * @copyright 2006 MDLF, Inc.
+ * @license http://www.gnu.org/licenses/gpl.txt
+ * @link http://www.campware.org
+ *
+ */
+
+// Do not allow remote execution
+$arr = array_diff_assoc($_SERVER, $_ENV);
+if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
+    header("HTTP/1.1 400");
+    header("Content-type: text/plain; charset=UTF-8");
+    echo "400 Not executable\r\n";
+    exit(1);
+}
+
+require_once('installInit.php');
+require_once('installScheduler.php');
+
+echo " * Scheduler install complete\n";
+
+?>

campcaster/src/products/scheduler/bin/installInit.php

@@ -0,0 +1,80 @@
+<?php
+if (!function_exists('pg_connect')) {
+    trigger_error("PostgreSQL PHP extension required and not found.", E_USER_ERROR);
+    exit(2);
+}
+
+require_once('DB.php');
+
+function camp_db_table_exists($p_name)
+{
+    global $CC_DBC;
+    $sql = "SELECT * FROM ".$p_name;
+    $result = $CC_DBC->GetOne($sql);
+    if (PEAR::isError($result)) {
+        return false;
+    }
+    return true;
+}
+
+function camp_install_query($sql)
+{
+    global $CC_DBC;
+    $result = $CC_DBC->query($sql);
+    if (PEAR::isError($result)) {
+        echo "Error! ".$result->getMessage()."\n";
+        echo "   SQL statement was:\n";
+        echo "   ".$sql."\n\n";
+    } else {
+        echo "done.\n";
+    }
+}
+
+$options = getopt("c:");
+
+if (!$options) {
+    echo "\nYou must specific the config file with -c.\n\n";
+    exit;
+}
+
+$configFile = $options['c'];
+if (!file_exists($configFile)) {
+    echo "\nThe config file '$configFile' does not exist.\n\n";
+    exit;
+}
+
+echo " * Using config file $configFile\n";
+
+$xml = file_get_contents($configFile);
+$parser = xml_parser_create();
+xml_parse_into_struct($parser, $xml, $vals, $index);
+xml_parser_free($parser);
+
+$CC_CONFIG['dsn'] = array('hostspec' => 'localhost',
+                          'phptype' => 'pgsql');
+
+// Get the user index
+$userIndex = $index['SIMPLECONNECTIONMANAGER'][0];
+$CC_CONFIG['dsn']['username'] = $vals[$userIndex]['attributes']['USERNAME'];
+$CC_CONFIG['dsn']['password'] = $vals[$userIndex]['attributes']['PASSWORD'];
+$CC_CONFIG['dsn']['database'] = $vals[$userIndex]['attributes']['DSN'];
+
+$CC_CONFIG['playlogTable'] = 'playlog';
+$CC_CONFIG['scheduleTable'] = 'schedule';
+$CC_CONFIG['backupTable'] = 'backup';
+
+$CC_DBC = DB::connect($CC_CONFIG['dsn'], TRUE);
+if (PEAR::isError($CC_DBC)) {
+    echo $CC_DBC->getMessage()."\n";
+    echo $CC_DBC->getUserInfo()."\n";
+    echo "Database connection problem.\n";
+    echo "Check if database '{$CC_CONFIG['dsn']['database']}' exists".
+        " with corresponding permissions.\n";
+    exit(1);
+} else {
+    echo " * Connected to database\n";
+}
+
+$CC_DBC->setFetchMode(DB_FETCHMODE_ASSOC);
+
+?>

campcaster/src/products/scheduler/bin/installScheduler.php

@@ -0,0 +1,51 @@
+<?php
+// Do not allow remote execution
+$arr = array_diff_assoc($_SERVER, $_ENV);
+if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
+    header("HTTP/1.1 400");
+    header("Content-type: text/plain; charset=UTF-8");
+    echo "400 Not executable\r\n";
+    exit(1);
+}
+
+if (!camp_db_table_exists($CC_CONFIG['scheduleTable'])) {
+    echo " * Creating database table ".$CC_CONFIG['scheduleTable']."...";
+    $sql = "CREATE TABLE ".$CC_CONFIG['scheduleTable']."("
+        ."   id          BIGINT      NOT NULL,"
+        ."   playlist    BIGINT      NOT NULL,"
+        ."   starts      TIMESTAMP   NOT NULL,"
+        ."   ends        TIMESTAMP   NOT NULL,"
+        ."   PRIMARY KEY(id))";
+    camp_install_query($sql);
+} else {
+    echo " * Skipping: database table already exists: ".$CC_CONFIG['scheduleTable']."\n";
+}
+
+
+if (!camp_db_table_exists($CC_CONFIG['playlogTable'])) {
+    echo " * Creating database table ".$CC_CONFIG['playlogTable']."...";
+    $sql = "CREATE TABLE ".$CC_CONFIG['playlogTable']."("
+        ."   id            BIGINT      NOT NULL,"
+        ."   audioClipId   BIGINT      NOT NULL,"
+        ."   timestamp     TIMESTAMP   NOT NULL,"
+        ."   PRIMARY KEY(id))";
+    camp_install_query($sql);
+} else {
+    echo " * Skipping: database table already exists: ".$CC_CONFIG['playlogTable']."\n";
+}
+
+
+if (!camp_db_table_exists($CC_CONFIG['backupTable'])) {
+    echo " * Creating database table ".$CC_CONFIG['backupTable']."...";
+    $sql = "CREATE TABLE ".$CC_CONFIG['backupTable']." ("
+        ."   token       VARCHAR(64)     NOT NULL,"
+        ."   sessionId   VARCHAR(64)     NOT NULL,"
+        ."   status      VARCHAR(32)     NOT NULL,"
+        ."   fromTime    TIMESTAMP       NOT NULL,"
+        ."   toTime      TIMESTAMP       NOT NULL,"
+        ."   PRIMARY KEY(token))";
+    camp_install_query($sql);
+} else {
+    echo " * Skipping: database table already exists: ".$CC_CONFIG['backupTable']."\n";
+}
+?>

campcaster/src/products/scheduler/bin/uninstall.php

@@ -0,0 +1,27 @@
+<?php
+/**
+ * @author Paul Baranowski <paul@paulbaranowski.org>
+ * @version $Revision: 2774 $
+ * @package Campcaster
+ * @subpackage Scheduler
+ * @copyright 2006 MDLF, Inc.
+ * @license http://www.gnu.org/licenses/gpl.txt
+ * @link http://www.campware.org
+ */
+
+// Do not allow remote execution.
+$arr = array_diff_assoc($_SERVER, $_ENV);
+if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
+    header("HTTP/1.1 400");
+    header("Content-type: text/plain; charset=UTF-8");
+    echo "400 Not executable\r\n";
+    exit;
+}
+
+
+require_once('installInit.php');
+require_once('uninstallScheduler.php');
+
+echo " * Scheduler uninstall complete\n";
+
+?>

campcaster/src/products/scheduler/bin/uninstallScheduler.php

@@ -0,0 +1,34 @@
+<?PHP
+// Do not allow remote execution.
+$arr = array_diff_assoc($_SERVER, $_ENV);
+if (isset($arr["DOCUMENT_ROOT"]) && ($arr["DOCUMENT_ROOT"] != "") ) {
+    header("HTTP/1.1 400");
+    header("Content-type: text/plain; charset=UTF-8");
+    echo "400 Not executable\r\n";
+    exit;
+}
+
+
+if (camp_db_table_exists($CC_CONFIG['scheduleTable'])) {
+    echo " * Removing database table ".$CC_CONFIG['scheduleTable']."...";
+    camp_install_query("DROP TABLE ".$CC_CONFIG['scheduleTable']);
+} else {
+    echo " * Skipping: database table ".$CC_CONFIG['scheduleTable']."\n";
+}
+
+if (camp_db_table_exists($CC_CONFIG['backupTable'])) {
+    echo " * Removing database table ".$CC_CONFIG['backupTable']."...";
+    camp_install_query("DROP TABLE ".$CC_CONFIG['backupTable']);
+} else {
+    echo " * Skipping: database table ".$CC_CONFIG['backupTable']."\n";
+}
+
+if (camp_db_table_exists($CC_CONFIG['playlogTable'])) {
+    echo " * Removing database table ".$CC_CONFIG['playlogTable']."...";
+    $sql = "DROP TABLE ".$CC_CONFIG['playlogTable'];
+    camp_install_query($sql);
+} else {
+    echo " * Skipping: database table ".$CC_CONFIG['playlogTable']."\n";
+}
+
+?>

campcaster/src/products/scheduler/src/BackupFactory.cxx

@@ -124,46 +124,3 @@ BackupFactory :: configure(const xmlpp::Element & element)
         throw std::invalid_argument("could not configure BackupFactory");
     }
 }
-
-
-/*------------------------------------------------------------------------------
- *  Install the backup factory.
- *----------------------------------------------------------------------------*/
-void
-BackupFactory :: install(void)                throw (std::exception)
-{
-    if (!backup) {
-        throw std::logic_error("BackupFactory not yet configured");
-    }
-
-    backup->install();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the backup factory has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-BackupFactory :: isInstalled(void)            throw (std::exception)
-{
-    if (!backup) {
-        throw std::logic_error("BackupFactory not yet configured");
-    }
-
-    return backup->isInstalled();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Install the backup factory.
- *----------------------------------------------------------------------------*/
-void
-BackupFactory :: uninstall(void)              throw (std::exception)
-{
-    if (!backup) {
-        throw std::logic_error("BackupFactory not yet configured");
-    }
-
-    backup->uninstall();
-}
-

campcaster/src/products/scheduler/src/BackupFactory.h

@@ -39,7 +39,6 @@
 #include <stdexcept>
 
 #include "LiveSupport/Core/Configurable.h"
-#include "LiveSupport/Core/Installable.h"
 #include "BackupInterface.h"
 
 
@@ -88,8 +87,7 @@ using namespace LiveSupport::Core;
  *  @version $Revision$
  *  @see PostgresqlBackup
  */
-class BackupFactory : virtual public Configurable,
+class BackupFactory : virtual public Configurable
-                      virtual public Installable
 {
     private:
         /**
@@ -158,38 +156,6 @@ class BackupFactory : virtual public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems,
-         *             especially if the BackupFactory was not yet configured.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems,
-         e             especially if the BackupFactory was not yet configured.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Return a backup.
          *

campcaster/src/products/scheduler/src/BackupInterface.h

@@ -40,7 +40,6 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include "LiveSupport/Core/Ptr.h"
-#include "LiveSupport/Core/Installable.h"
 #include "LiveSupport/Core/Playlist.h"
 #include "LiveSupport/Core/ScheduleEntry.h"
 #include "LiveSupport/StorageClient/StorageClientInterface.h"
@@ -78,7 +77,7 @@ using namespace LiveSupport::StorageClient;
  *  @author  $Author$
  *  @version $Revision$
  */
-class BackupInterface : virtual public Installable
+class BackupInterface
 {
     public:
         /**

campcaster/src/products/scheduler/src/DisplayScheduleMethodTest.cxx

@@ -88,7 +88,6 @@ DisplayScheduleMethodTest :: setUp(void)        throw (CPPUNIT_NS::Exception)
         storage->reset();
 
         schedule = scheduler->getSchedule();
-        schedule->install();
 
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
@@ -117,8 +116,6 @@ DisplayScheduleMethodTest :: setUp(void)        throw (CPPUNIT_NS::Exception)
 void
 DisplayScheduleMethodTest :: tearDown(void)     throw (CPPUNIT_NS::Exception)
 {
-    schedule->uninstall();
-
     authentication->logout(sessionId);
     sessionId.reset();
     authentication.reset();

campcaster/src/products/scheduler/src/GeneratePlayReportMethodTest.cxx

@@ -87,8 +87,6 @@ GeneratePlayReportMethodTest :: setUp(void)     throw (CPPUNIT_NS::Exception)
         storage->reset();
 
         playLog = scheduler->getPlayLog();
-        playLog->install();
-
         insertEntries();
 
     } catch (std::invalid_argument &e) {
@@ -116,8 +114,6 @@ GeneratePlayReportMethodTest :: setUp(void)     throw (CPPUNIT_NS::Exception)
 void
 GeneratePlayReportMethodTest :: tearDown(void)  throw (CPPUNIT_NS::Exception)
 {
-    playLog->uninstall();
-
     authentication->logout(sessionId);
     sessionId.reset();
     authentication.reset();

campcaster/src/products/scheduler/src/PlayLogFactory.cxx

@@ -114,45 +114,3 @@ PlayLogFactory :: configure(const xmlpp::Element & element)
     }
 }
 
-
-/*------------------------------------------------------------------------------
- *  Install the play log factory.
- *----------------------------------------------------------------------------*/
-void
-PlayLogFactory :: install(void)                 throw (std::exception)
-{
-    if (!playLog) {
-        throw std::logic_error("PlayLogFactory not yet configured");
-    }
-
-    playLog->install();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the factory has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-PlayLogFactory :: isInstalled(void)             throw (std::exception)
-{
-    if (!playLog) {
-        throw std::logic_error("PlayLogFactory not yet configured");
-    }
-
-    return playLog->isInstalled();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Uninstall the play log factory.
- *----------------------------------------------------------------------------*/
-void
-PlayLogFactory :: uninstall(void)               throw (std::exception)
-{
-    if (!playLog) {
-        throw std::logic_error("PlayLogFactory not yet configured");
-    }
-
-    playLog->uninstall();
-}
-

campcaster/src/products/scheduler/src/PlayLogFactory.h

@@ -43,7 +43,6 @@
 #include <stdexcept>
 
 #include "LiveSupport/Core/Configurable.h"
-#include "LiveSupport/Core/Installable.h"
 #include "PlayLogInterface.h"
 
 
@@ -89,8 +88,7 @@ using namespace LiveSupport::Core;
  *  @version $Revision$
  *  @see PostgresqlPlayLog
  */
-class PlayLogFactory : virtual public Configurable,
+class PlayLogFactory : virtual public Configurable
-                       virtual public Installable
 {
     private:
         /**
@@ -159,38 +157,6 @@ class PlayLogFactory : virtual public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems,
-         *             especially if the PlayLogFactory was not yet configured.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems,
-         e             especially if the PlayLogFactory was not yet configured.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Return a play log.
          *

campcaster/src/products/scheduler/src/PlayLogInterface.h

@@ -44,7 +44,6 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include "LiveSupport/Core/Ptr.h"
-#include "LiveSupport/Core/Installable.h"
 #include "LiveSupport/Core/Playlist.h"
 #include "LiveSupport/Core/PlayLogEntry.h"
 
@@ -72,7 +71,7 @@ using namespace LiveSupport::Core;
  *  @author  $Author$
  *  @version $Revision$
  */
-class PlayLogInterface : virtual public Installable
+class PlayLogInterface
 {
     public:
         /**

campcaster/src/products/scheduler/src/PlaylistEventContainerTest.cxx

@@ -99,13 +99,6 @@ PlaylistEventContainerTest :: setUp(void)       throw (CPPUNIT_NS::Exception)
         std::cerr << e.what() << std::endl;
         CPPUNIT_FAIL("error parsing configuration file");
     }
-    try {
-        schedule->install();
-        playLog->install();
-    } catch (std::exception &e) {
-        std::cerr << e.what() << std::endl;
-        CPPUNIT_FAIL("can't install schedule factory");
-    }
     audioPlayer->initialize();
 
     if (!(sessionId = authentication->login("root", "q"))) {
@@ -121,8 +114,6 @@ void
 PlaylistEventContainerTest :: tearDown(void)    throw (CPPUNIT_NS::Exception)
 {
     audioPlayer->deInitialize();
-    schedule->uninstall();
-    playLog->uninstall();
 
     playLog.reset();
     schedule.reset();

campcaster/src/products/scheduler/src/PlaylistEventTest.cxx

@@ -97,7 +97,6 @@ PlaylistEventTest :: setUp(void)                throw (CPPUNIT_NS::Exception)
     }
 
     audioPlayer->initialize();
-    playLog->install();
 
     duration.reset(new time_duration(seconds(30)));
 
@@ -113,7 +112,6 @@ PlaylistEventTest :: setUp(void)                throw (CPPUNIT_NS::Exception)
 void
 PlaylistEventTest :: tearDown(void)             throw (CPPUNIT_NS::Exception)
 {
-    playLog->uninstall();
     audioPlayer->deInitialize();
 
     duration.reset();

campcaster/src/products/scheduler/src/PostgresqlBackup.cxx

@@ -109,26 +109,6 @@ const std::string    scheduleExportFileName     = "meta-inf/scheduler.xml";
  *----------------------------------------------------------------------------*/
 const std::string   check1Stmt          = "SELECT 1";
 
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string   createStmt =
-    "CREATE TABLE backup\n"
-    "(\n"
-    "   token       VARCHAR(64)     NOT NULL,\n"
-    "   sessionId   VARCHAR(64)     NOT NULL,\n"
-    "   status      VARCHAR(32)     NOT NULL,\n"
-    "   fromTime    TIMESTAMP       NOT NULL,\n"
-    "   toTime      TIMESTAMP       NOT NULL,\n"
-    "\n"
-    "   PRIMARY KEY(token)\n"
-    ");";
-
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string   dropStmt            = "DROP TABLE backup;";
-
 /*------------------------------------------------------------------------------
  *  A statement to check if the backup table exists.
  *----------------------------------------------------------------------------*/
@@ -192,97 +172,6 @@ PostgresqlBackup :: configure(const xmlpp::Element & element)
 }
 
 
-/*------------------------------------------------------------------------------
- *  Install the PostgresqlBackup.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlBackup :: install(void)                     throw (std::exception)
-{
-    if (!isInstalled()) {
-        Ptr<Connection>::Ref    conn;
-        try {
-            conn = connectionManager->getConnection();
-            Ptr<Statement>::Ref     stmt(conn->createStatement());
-            stmt->execute(createStmt);
-            connectionManager->returnConnection(conn);
-        } catch (std::exception &e) {
-            if (conn) {
-                connectionManager->returnConnection(conn);
-            }
-            throw;
-        }
-    }
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the PostgresqlBackup has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-PostgresqlBackup :: isInstalled(void)                 throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        Ptr<Statement>::Ref     stmt;
-        ResultSet             * res;
-
-        conn = connectionManager->getConnection();
-
-        // see if we can connect at all
-        stmt.reset(conn->createStatement());
-        stmt->execute(check1Stmt);
-        res = stmt->getResultSet();
-        if (!res->next() || (res->getInt(1) != 1)) {
-            throw std::runtime_error("Can't connect to database");
-        }
-
-        // see if the backup table exists
-        try {
-            stmt.reset(conn->createStatement());
-            stmt->execute(backupCountStmt);
-            res = stmt->getResultSet();
-            if (!res->next() || (res->getInt(1) < 0)) {
-                connectionManager->returnConnection(conn);
-                return false;
-            }
-        } catch (std::exception &e) {
-            connectionManager->returnConnection(conn);
-            return false;
-        }
-
-        connectionManager->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            connectionManager->returnConnection(conn);
-        }
-        throw;
-    }
-
-    return true;
-}
-
-
-/*------------------------------------------------------------------------------
- *  Uninstall the PostgresqlBackup.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlBackup :: uninstall(void)                   throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        conn = connectionManager->getConnection();
-        Ptr<Statement>::Ref     stmt(conn->createStatement());
-        stmt->execute(dropStmt);
-        connectionManager->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            connectionManager->returnConnection(conn);
-        }
-        throw;
-    }
-}
-
-
 /*------------------------------------------------------------------------------
  *  Start a backup process.
  *----------------------------------------------------------------------------*/

campcaster/src/products/scheduler/src/PostgresqlBackup.h

@@ -215,36 +215,6 @@ class PostgresqlBackup : public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Start to create a backup by calling the storage, and also
          *  adding a backup of the schedule.

campcaster/src/products/scheduler/src/PostgresqlBackupTest.cxx

@@ -91,7 +91,6 @@ PostgresqlBackupTest :: setUp(void)              throw (CPPUNIT_NS::Exception)
         backup.reset(new PostgresqlBackup(connectionManager,
                                           storage,
                                           schedule));
-        backup->install();
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
     } catch (xmlpp::exception &e) {
@@ -118,9 +117,6 @@ PostgresqlBackupTest :: tearDown(void)           throw (CPPUNIT_NS::Exception)
     CPPUNIT_ASSERT_NO_THROW(
         authentication->logout(sessionId);
     );
-    CPPUNIT_ASSERT_NO_THROW(
-        backup->uninstall();
-    );
 
     remove(tempBackupTarFileName.c_str());
 }

campcaster/src/products/scheduler/src/PostgresqlPlayLog.cxx

@@ -68,25 +68,6 @@ const std::string PostgresqlPlayLog::check1Stmt = "SELECT 1";
 const std::string PostgresqlPlayLog::logCountStmt =
                                         "SELECT COUNT(*) FROM playLog";
 
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string PostgresqlPlayLog::createStmt =
-    "CREATE TABLE playLog\n"
-    "(\n"
-    "   id            BIGINT      NOT NULL,\n"
-    "   audioClipId   BIGINT      NOT NULL,\n"
-    "   timestamp     TIMESTAMP   NOT NULL,\n"
-    "\n"
-    "   PRIMARY KEY(id)\n"
-    ");";
-
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string PostgresqlPlayLog::dropStmt =
-    "DROP TABLE playLog;";
-
 /*------------------------------------------------------------------------------
  *  The SQL statement for adding a play log entry.
  *  It's a simple insert.
@@ -131,97 +112,6 @@ PostgresqlPlayLog :: configure(const xmlpp::Element & element)
 }
 
 
-/*------------------------------------------------------------------------------
- *  Install the PostgresqlPlayLog.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlPlayLog :: install(void)                     throw (std::exception)
-{
-    if (!isInstalled()) {
-        Ptr<Connection>::Ref    conn;
-        try {
-            conn = cm->getConnection();
-            Ptr<Statement>::Ref     stmt(conn->createStatement());
-            stmt->execute(createStmt);
-            cm->returnConnection(conn);
-        } catch (std::exception &e) {
-            if (conn) {
-                cm->returnConnection(conn);
-            }
-            throw std::logic_error(e.what());
-        }
-    }
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the PostgresqlPlayLog has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-PostgresqlPlayLog :: isInstalled(void)                 throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        Ptr<Statement>::Ref     stmt;
-        ResultSet             * res;
-
-        conn = cm->getConnection();
-
-        // see if we can connect at all
-        stmt.reset(conn->createStatement());
-        stmt->execute(check1Stmt);
-        res = stmt->getResultSet();
-        if (!res->next() || (res->getInt(1) != 1)) {
-            throw std::runtime_error("Can't connect to database");
-        }
-
-        // see if the schedule table exists
-        try {
-            stmt.reset(conn->createStatement());
-            stmt->execute(logCountStmt);
-            res = stmt->getResultSet();
-            if (!res->next() || (res->getInt(1) < 0)) {
-                cm->returnConnection(conn);
-                return false;
-            }
-        } catch (std::exception &e) {
-            cm->returnConnection(conn);
-            return false;
-        }
-
-        cm->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            cm->returnConnection(conn);
-        }
-        throw;
-    }
-
-    return true;
-}
-
-
-/*------------------------------------------------------------------------------
- *  Uninstall the PostgresqlPlayLog.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlPlayLog :: uninstall(void)                   throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        conn = cm->getConnection();
-        Ptr<Statement>::Ref     stmt(conn->createStatement());
-        stmt->execute(dropStmt);
-        cm->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            cm->returnConnection(conn);
-        }
-        throw std::logic_error(e.what());
-    }
-}
-
-
 /*------------------------------------------------------------------------------
  *  Add a new play log entry
  *----------------------------------------------------------------------------*/

campcaster/src/products/scheduler/src/PostgresqlPlayLog.h

@@ -102,16 +102,6 @@ class PostgresqlPlayLog : public Configurable,
          */
         static const std::string    logCountStmt;
 
-        /**
-         *  The SQL create statement used in the installation step.
-         */
-        static const std::string    createStmt;
-
-        /**
-         *  The SQL drop statement used in the uninstallation step.
-         */
-        static const std::string    dropStmt;
-
         /**
          *  The SQL statement for adding a play log entry.
          */
@@ -185,36 +175,6 @@ class PostgresqlPlayLog : public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Add a new entry to the play log.
          *

campcaster/src/products/scheduler/src/PostgresqlPlayLogTest.cxx

@@ -77,7 +77,6 @@ PostgresqlPlayLogTest :: setUp(void)            throw (CPPUNIT_NS::Exception)
         cm = scheduler->getConnectionManager();
 
         playLog.reset(new PostgresqlPlayLog(cm));
-        playLog->install();
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
     } catch (xmlpp::exception &e) {
@@ -92,13 +91,6 @@ PostgresqlPlayLogTest :: setUp(void)            throw (CPPUNIT_NS::Exception)
 void
 PostgresqlPlayLogTest :: tearDown(void)         throw (CPPUNIT_NS::Exception)
 {
-    try {
-        playLog->uninstall();
-    } catch (std::exception &e) {
-        std::string eMsg = "cannot uninstall playlog:\n";
-        eMsg += e.what();
-        CPPUNIT_FAIL(eMsg);
-    }
     playLog.reset();
     cm.reset();
 }

campcaster/src/products/scheduler/src/PostgresqlSchedule.cxx

@@ -90,26 +90,6 @@ const std::string PostgresqlSchedule::check1Stmt = "SELECT 1";
 const std::string PostgresqlSchedule::scheduleCountStmt =
                                         "SELECT COUNT(*) FROM schedule";
 
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string PostgresqlSchedule::createStmt =
-    "CREATE TABLE schedule\n"
-    "(\n"
-    "   id          BIGINT      NOT NULL,\n"
-    "   playlist    BIGINT      NOT NULL,\n"
-    "   starts      TIMESTAMP   NOT NULL,\n"
-    "   ends        TIMESTAMP   NOT NULL,\n"
-    "\n"
-    "   PRIMARY KEY(id)\n"
-    ");";
-
-/*------------------------------------------------------------------------------
- *  The SQL create statement, used for installation.
- *----------------------------------------------------------------------------*/
-const std::string PostgresqlSchedule::dropStmt =
-    "DROP TABLE schedule;";
-
 /*------------------------------------------------------------------------------
  *  The SQL statement for querying if a timeframe is available.
  *  The parameters for this call are: starts, starts, ends, ends, starts, ends,
@@ -215,97 +195,6 @@ PostgresqlSchedule :: configure(const xmlpp::Element & element)
 }
 
 
-/*------------------------------------------------------------------------------
- *  Install the PostgresqlSchedule.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlSchedule :: install(void)                     throw (std::exception)
-{
-    if (!isInstalled()) {
-        Ptr<Connection>::Ref    conn;
-        try {
-            conn = cm->getConnection();
-            Ptr<Statement>::Ref     stmt(conn->createStatement());
-            stmt->execute(createStmt);
-            cm->returnConnection(conn);
-        } catch (std::exception &e) {
-            if (conn) {
-                cm->returnConnection(conn);
-            }
-            throw;
-        }
-    }
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the PostgresqlSchedule has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-PostgresqlSchedule :: isInstalled(void)                 throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        Ptr<Statement>::Ref     stmt;
-        ResultSet             * res;
-
-        conn = cm->getConnection();
-
-        // see if we can connect at all
-        stmt.reset(conn->createStatement());
-        stmt->execute(check1Stmt);
-        res = stmt->getResultSet();
-        if (!res->next() || (res->getInt(1) != 1)) {
-            throw std::runtime_error("Can't connect to database");
-        }
-
-        // see if the schedule table exists
-        try {
-            stmt.reset(conn->createStatement());
-            stmt->execute(scheduleCountStmt);
-            res = stmt->getResultSet();
-            if (!res->next() || (res->getInt(1) < 0)) {
-                cm->returnConnection(conn);
-                return false;
-            }
-        } catch (std::exception &e) {
-            cm->returnConnection(conn);
-            return false;
-        }
-
-        cm->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            cm->returnConnection(conn);
-        }
-        throw;
-    }
-
-    return true;
-}
-
-
-/*------------------------------------------------------------------------------
- *  Uninstall the PostgresqlSchedule.
- *----------------------------------------------------------------------------*/
-void
-PostgresqlSchedule :: uninstall(void)                   throw (std::exception)
-{
-    Ptr<Connection>::Ref    conn;
-    try {
-        conn = cm->getConnection();
-        Ptr<Statement>::Ref     stmt(conn->createStatement());
-        stmt->execute(dropStmt);
-        cm->returnConnection(conn);
-    } catch (std::exception &e) {
-        if (conn) {
-            cm->returnConnection(conn);
-        }
-        throw;
-    }
-}
-
-
 /*------------------------------------------------------------------------------
  *  Check if a timeframe is available.
  *----------------------------------------------------------------------------*/

campcaster/src/products/scheduler/src/PostgresqlSchedule.h

@@ -117,16 +117,6 @@ class PostgresqlSchedule : public Configurable,
          */
         static const std::string    scheduleCountStmt;
 
-        /**
-         *  The SQL create statement used in the installation step.
-         */
-        static const std::string    createStmt;
-
-        /**
-         *  The SQL drop statement used in the uninstallation step.
-         */
-        static const std::string    dropStmt;
-
         /**
          *  The SQL statement for querying if a time frame is available.
          */
@@ -237,36 +227,6 @@ class PostgresqlSchedule : public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Check if a timeframe is available for scheduling.
          *

campcaster/src/products/scheduler/src/PostgresqlScheduleTest.cxx

@@ -79,7 +79,6 @@ PostgresqlScheduleTest :: setUp(void)           throw (CPPUNIT_NS::Exception)
         cm = scheduler->getConnectionManager();
 
         schedule.reset(new PostgresqlSchedule(cm));
-        schedule->install();
 
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
@@ -95,7 +94,6 @@ PostgresqlScheduleTest :: setUp(void)           throw (CPPUNIT_NS::Exception)
 void
 PostgresqlScheduleTest :: tearDown(void)        throw (CPPUNIT_NS::Exception)
 {
-    schedule->uninstall();
     schedule.reset();
     cm.reset();
 }

campcaster/src/products/scheduler/src/RemoveFromScheduleMethodTest.cxx

@@ -87,7 +87,6 @@ RemoveFromScheduleMethodTest :: setUp(void)     throw (CPPUNIT_NS::Exception)
         storage->reset();
 
         schedule = scheduler->getSchedule();
-        schedule->install();
 
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
@@ -114,8 +113,6 @@ RemoveFromScheduleMethodTest :: setUp(void)     throw (CPPUNIT_NS::Exception)
 void
 RemoveFromScheduleMethodTest :: tearDown(void)  throw (CPPUNIT_NS::Exception)
 {
-    schedule->uninstall();
-
     authentication->logout(sessionId);
     sessionId.reset();
     authentication.reset();

campcaster/src/products/scheduler/src/RescheduleMethodTest.cxx

@@ -85,7 +85,6 @@ RescheduleMethodTest :: setUp(void)             throw (CPPUNIT_NS::Exception)
         storage->reset();
 
         schedule = scheduler->getSchedule();
-        schedule->install();
 
     } catch (std::invalid_argument &e) {
         CPPUNIT_FAIL("semantic error in configuration file");
@@ -112,8 +111,6 @@ RescheduleMethodTest :: setUp(void)             throw (CPPUNIT_NS::Exception)
 void
 RescheduleMethodTest :: tearDown(void)          throw (CPPUNIT_NS::Exception)
 {
-    schedule->uninstall();
-
     authentication->logout(sessionId);
     sessionId.reset();
     authentication.reset();

campcaster/src/products/scheduler/src/RpcBackupTest.cxx

@@ -97,8 +97,6 @@ RpcBackupTest :: setUp(void)                    throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
-
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
 
@@ -129,8 +127,6 @@ void
 RpcBackupTest :: tearDown(void)                 throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
-    
     CPPUNIT_ASSERT(sessionId);
 
     XmlRpc::XmlRpcValue     parameters;

campcaster/src/products/scheduler/src/RpcDisplayScheduleTest.cxx

@@ -87,8 +87,6 @@ RpcDisplayScheduleTest :: setUp(void)           throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
-
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
 
@@ -119,7 +117,6 @@ void
 RpcDisplayScheduleTest :: tearDown(void)        throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/RpcGeneratePlayReportTest.cxx

@@ -85,7 +85,6 @@ RpcGeneratePlayReportTest :: setUp(void)        throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
     insertEntries();
 
     XmlRpc::XmlRpcValue     parameters;
@@ -118,7 +117,6 @@ void
 RpcGeneratePlayReportTest :: tearDown(void)     throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/RpcGetSchedulerTimeTest.cxx

@@ -83,7 +83,6 @@ RpcGetSchedulerTimeTest :: setUp(void)          throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
 }
 
 
@@ -94,7 +93,6 @@ void
 RpcGetSchedulerTimeTest :: tearDown(void)       throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 }
 
 

campcaster/src/products/scheduler/src/RpcGetVersionTest.cxx

@@ -66,7 +66,6 @@ void
 RpcGetVersionTest :: setUp(void)                throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->install();
 }
 
 
@@ -77,7 +76,6 @@ void
 RpcGetVersionTest :: tearDown(void)             throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 }
 
 

campcaster/src/products/scheduler/src/RpcRemoveFromScheduleTest.cxx

@@ -63,7 +63,6 @@ void
 RpcRemoveFromScheduleTest :: setUp(void)        throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->install();
 
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
@@ -95,7 +94,6 @@ void
 RpcRemoveFromScheduleTest :: tearDown(void)     throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/RpcRescheduleTest.cxx

@@ -84,8 +84,6 @@ RpcRescheduleTest :: setUp(void)                throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
-
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
 
@@ -116,7 +114,6 @@ void
 RpcRescheduleTest :: tearDown(void)             throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/RpcStopCurrentlyPlayingTest.cxx

@@ -84,8 +84,6 @@ RpcStopCurrentlyPlayingTest :: setUp(void)      throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
-
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
 
@@ -116,7 +114,6 @@ void
 RpcStopCurrentlyPlayingTest :: tearDown(void)   throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/RpcUploadPlaylistTest.cxx

@@ -83,8 +83,6 @@ RpcUploadPlaylistTest :: setUp(void)            throw (CPPUNIT_NS::Exception)
         }
     }
 
-    daemon->install();
-
     XmlRpc::XmlRpcValue     parameters;
     XmlRpc::XmlRpcValue     result;
 
@@ -115,7 +113,6 @@ void
 RpcUploadPlaylistTest :: tearDown(void)         throw (CPPUNIT_NS::Exception)
 {
     Ptr<SchedulerDaemon>::Ref   daemon = SchedulerDaemon::getInstance();
-    daemon->uninstall();
 
     CPPUNIT_ASSERT(sessionId);
 

campcaster/src/products/scheduler/src/ScheduleFactory.cxx

@@ -113,46 +113,3 @@ ScheduleFactory :: configure(const xmlpp::Element & element)
         throw std::invalid_argument("no storage client factories to configure");
     }
 }
-
-
-/*------------------------------------------------------------------------------
- *  Install the schedule factory.
- *----------------------------------------------------------------------------*/
-void
-ScheduleFactory :: install(void)                throw (std::exception)
-{
-    if (!schedule) {
-        throw std::logic_error("ScheduleFactory not yet configured");
-    }
-
-    schedule->install();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the schedule factory has already been installed.
- *----------------------------------------------------------------------------*/
-bool
-ScheduleFactory :: isInstalled(void)            throw (std::exception)
-{
-    if (!schedule) {
-        throw std::logic_error("ScheduleFactory not yet configured");
-    }
-
-    return schedule->isInstalled();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Install the schedule factory.
- *----------------------------------------------------------------------------*/
-void
-ScheduleFactory :: uninstall(void)              throw (std::exception)
-{
-    if (!schedule) {
-        throw std::logic_error("ScheduleFactory not yet configured");
-    }
-
-    schedule->uninstall();
-}
-

campcaster/src/products/scheduler/src/ScheduleFactory.h

@@ -43,7 +43,6 @@
 #include <stdexcept>
 
 #include "LiveSupport/Core/Configurable.h"
-#include "LiveSupport/Core/Installable.h"
 #include "ScheduleInterface.h"
 
 
@@ -89,8 +88,7 @@ using namespace LiveSupport::Core;
  *  @version $Revision$
  *  @see PostgresqlSchedule
  */
-class ScheduleFactory : virtual public Configurable,
+class ScheduleFactory : virtual public Configurable
-                        virtual public Installable
 {
     private:
         /**
@@ -159,38 +157,6 @@ class ScheduleFactory : virtual public Configurable,
                                                 throw (std::invalid_argument,
                                                        std::logic_error);
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems,
-         *             especially if the ScheduleFactory was not yet configured.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems,
-         e             especially if the ScheduleFactory was not yet configured.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Return a schedule.
          *

campcaster/src/products/scheduler/src/ScheduleInterface.h

@@ -44,7 +44,6 @@
 #include <boost/date_time/posix_time/posix_time.hpp>
 
 #include "LiveSupport/Core/Ptr.h"
-#include "LiveSupport/Core/Installable.h"
 #include "LiveSupport/Core/Playlist.h"
 #include "LiveSupport/Core/ScheduleEntry.h"
 
@@ -72,7 +71,7 @@ using namespace LiveSupport::Core;
  *  @author  $Author$
  *  @version $Revision$
  */
-class ScheduleInterface : virtual public Installable
+class ScheduleInterface
 {
     public:
         /**

campcaster/src/products/scheduler/src/SchedulerDaemon.cxx

@@ -302,103 +302,12 @@ SchedulerDaemon :: registerXmlRpcFunctions(
 }
 
 
-/*------------------------------------------------------------------------------
- *  Install the scheduler daemon.
- *----------------------------------------------------------------------------*/
-void
-SchedulerDaemon :: install(void)                throw (std::exception)
-{
-    if (!isInstalled()) {
-        // TODO: check if we have already been configured
-        Ptr<ScheduleFactory>::Ref   sf  = ScheduleFactory::getInstance();
-        sf->install();
-        Ptr<PlayLogFactory>::Ref    plf = PlayLogFactory::getInstance();
-        plf->install();
-        Ptr<BackupFactory>::Ref     bf  = BackupFactory::getInstance();
-        bf->install();
-    }
-}
-
-
-/*------------------------------------------------------------------------------
- *  Check to see if the scheduler has been installed.
- *----------------------------------------------------------------------------*/
-bool
-SchedulerDaemon :: isInstalled(void)            throw (std::exception)
-{
-    // TODO: check if we have already been configured
-    Ptr<ScheduleFactory>::Ref   sf  = ScheduleFactory::getInstance();
-    Ptr<PlayLogFactory>::Ref    plf = PlayLogFactory::getInstance();
-    Ptr<BackupFactory>::Ref     bf  = BackupFactory::getInstance();
-
-    if (!sf || !plf || !bf) {
-        throw std::logic_error("couldn't initialize factories");
-    }
-    
-    return sf->isInstalled() && plf->isInstalled() && bf->isInstalled();
-}
-
-
-/*------------------------------------------------------------------------------
- *  Install the scheduler daemon.
- *----------------------------------------------------------------------------*/
-void
-SchedulerDaemon :: uninstall(void)              throw (std::exception)
-{
-    // TODO: check if we have already been configured
-    Ptr<BackupFactory>::Ref     bf  = BackupFactory::getInstance();
-    Ptr<PlayLogFactory>::Ref    plf = PlayLogFactory::getInstance();
-    Ptr<ScheduleFactory>::Ref   sf  = ScheduleFactory::getInstance();
-
-    if (!bf || !plf || !sf) {
-        throw std::logic_error("couldn't initialize factories");
-    }
-
-    bool                isOK = true;
-    std::stringstream   errorMessage("error uninstalling factories:\n");
-    
-    try {
-        bf->uninstall();
-    } catch (std::exception &e) {
-        isOK = false;
-        errorMessage << e.what() << std::endl;
-    }
-    
-    try {
-        plf->uninstall();
-    } catch (std::exception &e) {
-        isOK = false;
-        errorMessage << e.what() << std::endl;
-    }
-    
-    try {
-        sf->uninstall();
-    } catch (std::exception &e) {
-        isOK = false;
-        errorMessage << e.what() << std::endl;
-    }
-    
-    if (!isOK) {
-        throw std::logic_error(errorMessage.str());
-    }
-}
-
-
 /*------------------------------------------------------------------------------
  *  Execute daemon startup functions.
  *----------------------------------------------------------------------------*/
 void
 SchedulerDaemon :: startup (void)                   throw (std::logic_error)
 {
-    try {
-        if (!isInstalled()) {
-            install();
-        }
-    } catch (std::exception &e) {
-        throw std::logic_error(std::string("database installation problem: ")
-                               + e.what());
-    }
-
     try {
         sessionId      = authentication->login(login, password);
     } catch (XmlRpcException &e) {

campcaster/src/products/scheduler/src/SchedulerDaemon.h

@@ -58,7 +58,6 @@
 #include <XmlRpc.h>
 
 #include "LiveSupport/Core/Ptr.h"
-#include "LiveSupport/Core/Installable.h"
 #include "LiveSupport/Core/Configurable.h"
 #include "LiveSupport/Core/SessionId.h"
 #include "LiveSupport/Db/ConnectionManagerInterface.h"
@@ -171,22 +170,11 @@ using namespace LiveSupport::PlaylistExecutor;
  *  @see ScheduleFactory
  *  @see XmlRpcDaemon
  */
-class SchedulerDaemon : public Installable,
+class SchedulerDaemon : public Configurable,
-                        public Configurable,
                         public XmlRpcDaemon
 {
     private:
 
-        /**
-         *  The SQL create statement used in the installation step.
-         */
-        static const std::string    createStmt;
-
-        /**
-         *  The SQL drop statement used in the uninstallation step.
-         */
-        static const std::string    dropStmt;
-
         /**
          *  A SQL statement to check if the database can be accessed.
          */
@@ -447,36 +435,6 @@ class SchedulerDaemon : public Installable,
             return audioPlayer;
         }
 
-        /**
-         *  Install the component.
-         *  This step involves creating the environment in which the component
-         *  will run. This may be creation of coniguration files,
-         *  database tables, etc.
-         *
-         *  @exception std::exception on installation problems.
-         */
-        virtual void
-        install(void)                           throw (std::exception);
-
-        /**
-         *  Check to see if the component has already been installed.
-         *
-         *  @return true if the component is properly installed,
-         *          false otherwise
-         *  @exception std::exception on generic problems
-         */
-        virtual bool
-        isInstalled(void)                       throw (std::exception);
-
-        /**
-         *  Uninstall the component.
-         *  Removes all the resources created in the install step.
-         *
-         *  @exception std::exception on unistallation problems.
-         */
-        virtual void
-        uninstall(void)                         throw (std::exception);
-
         /**
          *  Shut down the daemon.
          *  This function is public only because the signal handler

campcaster/src/products/scheduler/src/UploadPlaylistMethodTest.cxx

@@ -84,7 +84,6 @@ UploadPlaylistMethodTest :: setUp(void)         throw (CPPUNIT_NS::Exception)
         storage->reset();
 
         schedule = scheduler->getSchedule();
-        schedule->install();
 
     } catch (XmlRpcException &e) {
         std::cerr << "caught XmlRpcException durng setUp" << std::endl
@@ -113,8 +112,6 @@ UploadPlaylistMethodTest :: setUp(void)         throw (CPPUNIT_NS::Exception)
 void
 UploadPlaylistMethodTest :: tearDown(void)      throw (CPPUNIT_NS::Exception)
 {
-    schedule->uninstall();
-
     authentication->logout(sessionId);
     sessionId.reset();
     authentication.reset();

campcaster/src/products/scheduler/src/main.cxx

@@ -86,11 +86,6 @@ static const struct option longOptions[] = {
     { 0, 0, 0, 0 }
 };
 
-/**
- *  The start command: "install"
- */
-static const std::string installCommand = "install";
-
 /**
  *  The start command: "start"
  */
@@ -106,11 +101,6 @@ static const std::string statusCommand = "status";
  */
 static const std::string stopCommand = "stop";
 
-/**
- *  The stop command: "uninstall"
- */
-static const std::string uninstallCommand = "uninstall";
-
 
 /* ===============================================  local function prototypes */
 
@@ -200,9 +190,7 @@ int main (  int     argc,
     daemon->setBackground(!debugMode);
 
     try {
-        if (installCommand == argv[optind]) {
+        if (startCommand == argv[optind]) {
-            daemon->install();
-        } else if (startCommand == argv[optind]) {
             daemon->start();
         } else if (statusCommand == argv[optind]) {
             std::cout << "The Scheduler Daemon is "
@@ -210,8 +198,6 @@ int main (  int     argc,
                       << "running" << std::endl;
         } else if (stopCommand == argv[optind]) {
             daemon->stop();
-        } else if (uninstallCommand == argv[optind]) {
-            daemon->uninstall();
         } else {
             printUsage(argv[0], std::cout);
             exit(EXIT_FAILURE);
@@ -248,7 +234,7 @@ printUsage (    const char      invocation[],
        << std::endl
        << "Usage: " << invocation << " [OPTION] COMMAND"
        << std::endl
-       << "  COMMAND is one of: install, start, stop, status or uninstall"
+       << "  COMMAND is one of: start, stop, or status"
                                                                     << std::endl
        << std::endl
        << "  mandatory options:" << std::endl