com.streambase.liveview.server.table.plugin

## Class TableProviderManager

- java.lang.Object
- - com.streambase.liveview.server.table.plugin.TableProviderManager

-     public class TableProviderManager
      extends Object

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static boolean` | `restartIsOK`
    `protected PriorityBlockingQueue<TableProviderControlImpl>` | `restartQueue`
    `protected Map<String,TableProviderControlImpl>` | `tableProviderMap`

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `addDependentTable(CatalogedTable baseTable, String dependentTableName)` It adds the dependent table name to the dependents maps that every table provider has.
    `boolean` | `addingNew(String tableName)` This method should be called as early as possible in the createTable path.
    `void` | `addTableProvider(ExternalServerConnectionType externalServer, int retryCount)` Connect to a TableProvider, which then allows for remote connections as if they were LiveView Tables
    `Map<String,com.streambase.liveview.config.AbstractConfigObject>` | `compileLVConfs(List<File> tableFiles, boolean buildYaml)`
    `void` | `createTable(String name, LiveviewConfiguration conf, boolean saveInProject)` Does pre-checks, saves lvconf file and registers the table in defined state with the services layer
    `void` | `deleteTable(CatalogedTable catalogedTable)`
    `void` | `dropTables(List<String> tables)`
    `static TableProviderManager` | `get()`
    `(package private) TableColumnsTable` | `getColumnsTable()`
    `LiveViewServerConfig` | `getConfig()`
    `File` | `getCreateTableDir(boolean create)`
    `static String` | `getJavaClassname(ExternalServerConnectionType externalServer)`
    `File` | `getProjectBin()` Get the projectBin, which is the writable base directory where all stuff that we write should go.
    `(package private) Set<String>` | `getTableDependants(String baseCatalogedName)` It returns the set of dependent tables of a particular cataloged table.
    `TablesTable` | `getTablesTable()`
    `static boolean` | `hasDangerousConnection(com.streambase.liveview.config.AbstractConfigObject configObject)`
    `static void` | `initialize(LiveViewServer lvServer)`
    `static void` | `initialize(TablesTable tt, TableColumnsTable tct, LiveViewServerConfig conf, StreamBaseConnectionPool sbConnPool)`
    `(package private) void` | `killQueriesAndPublishers(String tableName, LiveViewException exceptionToBeDeliveredToQueriesBeforeClosing)` Kills all queries and publishers that are attached to it.
    `(package private) void` | `queueRestart(TableProviderControlImpl control)`
    `void` | `registerDependentTables(TableType tableInfo, CatalogedTable baseCatalogedTable, boolean useDynamicStates)`
    `void` | `registerNewDynamicTable(String name, LiveviewConfiguration.DataTable dataTable, Table.TableStatus initialStatus, String statusMessage)`
    `boolean` | `removeNew(String tableName)` This method MUST be called with the same table name if AddingNew has been called.
    `void` | `removeTableProvider(String id)` Disconnect a previously-connected TableProvider.
    `void` | `saveLVConf(String name, LiveviewConfiguration conf, boolean saveInProject)`
    `void` | `shutdown()`
    `void` | `startTables(List<String> tables)`
    `void` | `validateDependentTables(LiveviewConfiguration conf)`
    `void` | `validateTablesContainers()`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### restartIsOK

          public static boolean restartIsOK

    - #### tableProviderMap

          protected Map<String,TableProviderControlImpl> tableProviderMap

    - #### restartQueue

          protected PriorityBlockingQueue<TableProviderControlImpl> restartQueue

  - ### Method Detail

    - #### queueRestart

          void queueRestart(TableProviderControlImpl control)

    - #### get

          public static TableProviderManager get()

    - #### initialize

          public static void initialize(LiveViewServer lvServer)

    - #### initialize

          public static void initialize(TablesTable tt,
                                        TableColumnsTable tct,
                                        LiveViewServerConfig conf,
                                        StreamBaseConnectionPool sbConnPool)

    - #### validateTablesContainers

          public void validateTablesContainers()

    - #### getTablesTable

          public TablesTable getTablesTable()

    - #### getColumnsTable

          TableColumnsTable getColumnsTable()

    - #### getConfig

          public LiveViewServerConfig getConfig()

      Returns:
        the config

    - #### addTableProvider

          public void addTableProvider(ExternalServerConnectionType externalServer,
                                       int retryCount)
                                throws LiveViewException

      Connect to a TableProvider, which then allows for remote connections as if they were LiveView Tables
      Parameters:
        `externalServer` - id must be unique
        `retryCount` - The number of failed tries we've already made.
      Throws:
        `LiveViewException`
      Since:
        LiveView 1.6

    - #### getJavaClassname

          public static String getJavaClassname(ExternalServerConnectionType externalServer)

    - #### getTableDependants

          Set<String> getTableDependants(String baseCatalogedName)

      It returns the set of dependent tables of a particular cataloged table. Returns null if base table doesn't exist
      Returns:

    - #### removeTableProvider

          public void removeTableProvider(String id)
                                   throws LiveViewException

      Disconnect a previously-connected TableProvider. This is called from outside, so no part has happened, yet, and it shouldn't be requeued for restart
      Parameters:
        `id` -
      Throws:
        `LiveViewException`
      Since:
        LiveView 1.6

    - #### shutdown

          public void shutdown()
                        throws LiveViewException

      Throws:
        `LiveViewException`

    - #### dropTables

          public void dropTables(List<String> tables)
                          throws LiveViewException,
                                 TupleException,
                                 StreamBaseException

      Parameters:
        `tables` -
      Throws:
        `LiveViewException`
        `TupleException`
        `StreamBaseException`

    - #### startTables

          public void startTables(List<String> tables)
                           throws LiveViewException,
                                  StreamBaseException,
                                  com.streambase.liveview.config.ConfigExceptionType.ConfigException,
                                  TupleException,
                                  NullValueException

      Parameters:
        `tables` -
      Throws:
        `LiveViewException`
        `StreamBaseException`
        `com.streambase.liveview.config.ConfigExceptionType.ConfigException`
        `TupleException`
        `NullValueException`

    - #### compileLVConfs

          public Map<String,com.streambase.liveview.config.AbstractConfigObject> compileLVConfs(List<File> tableFiles,
                                                                                                boolean buildYaml)
                                                                                         throws LiveViewException,
                                                                                                StreamBaseException

      Throws:
        `LiveViewException`
        `StreamBaseException`

    - #### getCreateTableDir

          public File getCreateTableDir(boolean create)

    - #### getProjectBin

          public File getProjectBin()

      Get the projectBin, which is the writable base directory where all stuff that we write should go.
      Returns:

    - #### deleteTable

          public void deleteTable(CatalogedTable catalogedTable)
                           throws TupleException,
                                  StreamBaseException

      Throws:
        `TupleException`
        `StreamBaseException`

    - #### killQueriesAndPublishers

          void killQueriesAndPublishers(String tableName,
                                        LiveViewException exceptionToBeDeliveredToQueriesBeforeClosing)
                                 throws LiveViewException

      Kills all queries and publishers that are attached to it. It also sends the exception to the query listener.
      Parameters:
        `id` -
      Throws:
        `LiveViewException`
        `InterruptedException`

    - #### addingNew

          public boolean addingNew(String tableName)

      This method should be called as early as possible in the createTable path. It is intended to prevent multiple clients from trying to create the same table simultaneously You must call RemoveNew(tableName) regardless if the table is created successfully or not.
      Parameters:
        `tableName` -
      Returns:
        true if the table is really new. False if the table exists, or is in the process of being created.

    - #### removeNew

          public boolean removeNew(String tableName)

      This method MUST be called with the same table name if AddingNew has been called.
      Parameters:
        `tableName` -
      Returns:
        true if the table was in the currently creating state.

    - #### createTable

          public void createTable(String name,
                                  LiveviewConfiguration conf,
                                  boolean saveInProject)
                           throws JAXBException,
                                  StreamBaseException

      Does pre-checks, saves lvconf file and registers the table in defined state with the services layer
      Parameters:
        `conf` -
        `saveInProject` - TODO
      Throws:
        `JAXBException`
        `StreamBaseException`

    - #### validateDependentTables

          public void validateDependentTables(LiveviewConfiguration conf)
                                       throws LiveViewException

      Throws:
        `LiveViewException`

    - #### saveLVConf

          public void saveLVConf(String name,
                                 LiveviewConfiguration conf,
                                 boolean saveInProject)
                          throws JAXBException,
                                 LiveViewException

      Throws:
        `JAXBException`
        `LiveViewException`

    - #### registerNewDynamicTable

          public void registerNewDynamicTable(String name,
                                              LiveviewConfiguration.DataTable dataTable,
                                              Table.TableStatus initialStatus,
                                              String statusMessage)
                                       throws LiveViewException

      Throws:
        `LiveViewException`

    - #### registerDependentTables

          public void registerDependentTables(TableType tableInfo,
                                              CatalogedTable baseCatalogedTable,
                                              boolean useDynamicStates)
                                       throws LiveViewException

      Throws:
        `LiveViewException`

    - #### hasDangerousConnection

          public static boolean hasDangerousConnection(com.streambase.liveview.config.AbstractConfigObject configObject)

    - #### addDependentTable

          public void addDependentTable(CatalogedTable baseTable,
                                        String dependentTableName)

      It adds the dependent table name to the dependents maps that every table provider has.
      Parameters:
        `baseTable` -
        `dependentTableName` -

Copyright © 2015–2018 Cloud Software Group, Inc.. All rights reserved.