* Licensed to the Apache Software Foundation (ASF) under one

* or more contributor license agreements.  See the NOTICE file

* distributed with this work for additional information

* regarding copyright ownership.  The ASF licenses this file

* to you under the Apache License, Version 2.0 (the

* "License"); you may not use this file except in compliance

* with the License.  You may obtain a copy of the License at

*

*     http://www.apache.org/licenses/LICENSE-2.0

*

* Unless required by applicable law or agreed to in writing, software

* distributed under the License is distributed on an "AS IS" BASIS,

* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

* See the License for the specific language governing permissions and

* limitations under the License.

*/

* This class is the interface between the application logic and the database

* store that contains the objects. Refrain putting any logic in mode.M* objects

* or in this file as former could be auto generated and this class would need

* to be made into a interface that can read both from a database and a

* filestore.

*/

  private static Properties prop = null;

  private static PersistenceManagerFactory pmf = null;

  private static Lock pmfPropLock = new ReentrantLock();

  private static final Log LOG = LogFactory.getLog(ObjectStore.class.getName());

  private static enum TXN_STATUS {

    NO_STATE, OPEN, COMMITED, ROLLBACK

  }

  private boolean isInitialized = false;

  private PersistenceManager pm = null;

  private Configuration hiveConf;

  int openTrasactionCalls = 0;

  private Transaction currentTransaction = null;

  private TXN_STATUS transactionStatus = TXN_STATUS.NO_STATE;

  public ObjectStore() {

  }

  public Configuration getConf() {

    return hiveConf;

  }

  /**

   * Called whenever this object is instantiated using ReflectionUils, and also

   * on connection retries. In cases of connection retries, conf will usually

   * contain modified values.

   */

  @SuppressWarnings("nls")

  public void setConf(Configuration conf) {

    // Although an instance of ObjectStore is accessed by one thread, there may

    // be many threads with ObjectStore instances. So the static variables

    // pmf and prop need to be protected with locks.

    pmfPropLock.lock();

    try {

      isInitialized = false;

      hiveConf = conf;

      Properties propsFromConf = getDataSourceProps(conf);

      boolean propsChanged = !propsFromConf.equals(prop);

      if (propsChanged) {

        pmf = null;

        prop = null;

      }

      assert(!isActiveTransaction());

      shutdown();

      // Always want to re-create pm as we don't know if it were created by the

      // most recent instance of the pmf

      pm = null;

      openTrasactionCalls = 0;

      currentTransaction = null;

      transactionStatus = TXN_STATUS.NO_STATE;

      initialize(propsFromConf);

      if (!isInitialized) {

        throw new RuntimeException(

        "Unable to create persistence manager. Check dss.log for details");

      } else {

        LOG.info("Initialized ObjectStore");

      }

    } finally {

      pmfPropLock.unlock();

    }

  }

  private ClassLoader classLoader;

  {

    classLoader = Thread.currentThread().getContextClassLoader();

    if (classLoader == null) {

      classLoader = ObjectStore.class.getClassLoader();

    }

  }

  @SuppressWarnings("nls")

  private void initialize(Properties dsProps) {

    LOG.info("ObjectStore, initialize called");

    prop = dsProps;

    pm = getPersistenceManager();

    isInitialized = pm != null;

    return;

  }

  /**

   * Properties specified in hive-default.xml override the properties specified

   * in jpox.properties.

   */

  @SuppressWarnings("nls")

  private static Properties getDataSourceProps(Configuration conf) {

    Properties prop = new Properties();

    Iterator<Map.Entry<String, String>> iter = conf.iterator();

    while (iter.hasNext()) {

      Map.Entry<String, String> e = iter.next();

      if (e.getKey().contains("datanucleus") || e.getKey().contains("jdo")) {

        Object prevVal = prop.setProperty(e.getKey(), e.getValue());

        if (LOG.isDebugEnabled()

            && !e.getKey().equals(HiveConf.ConfVars.METASTOREPWD.varname)) {

          LOG.debug("Overriding " + e.getKey() + " value " + prevVal

              + " from  jpox.properties with " + e.getValue());

        }

      }

    }

    if (LOG.isDebugEnabled()) {

      for (Entry<Object, Object> e : prop.entrySet()) {

        if (!e.getKey().equals(HiveConf.ConfVars.METASTOREPWD.varname)) {

          LOG.debug(e.getKey() + " = " + e.getValue());

        }

      }

    }

    return prop;

  }

  private static PersistenceManagerFactory getPMF() {

    if (pmf == null) {

      pmf = JDOHelper.getPersistenceManagerFactory(prop);

      DataStoreCache dsc = pmf.getDataStoreCache();

      if (dsc != null) {

        dsc.pinAll(true, MTable.class);

        dsc.pinAll(true, MStorageDescriptor.class);

        dsc.pinAll(true, MSerDeInfo.class);

        dsc.pinAll(true, MPartition.class);

        dsc.pinAll(true, MDatabase.class);

        dsc.pinAll(true, MType.class);

        dsc.pinAll(true, MFieldSchema.class);

        dsc.pinAll(true, MOrder.class);

      }

    }

    return pmf;

  }

  private PersistenceManager getPersistenceManager() {

    return getPMF().getPersistenceManager();

  }

  public void shutdown() {

    if (pm != null) {

      pm.close();

    }

  }

  /**

   * Opens a new one or the one already created Every call of this function must

   * have corresponding commit or rollback function call

   *

   * @return an active transaction

   */

  public boolean openTransaction() {

    openTrasactionCalls++;

    if (openTrasactionCalls == 1) {

      currentTransaction = pm.currentTransaction();

      currentTransaction.begin();

      transactionStatus = TXN_STATUS.OPEN;

    } else {

      // something is wrong since openTransactionCalls is greater than 1 but

      // currentTransaction is not active

      assert ((currentTransaction != null) && (currentTransaction.isActive()));

    }

    return currentTransaction.isActive();

  }

  /**

   * if this is the commit of the first open call then an actual commit is

   * called.

   *

   * @return Always returns true

   */

  @SuppressWarnings("nls")

  public boolean commitTransaction() {

    if (TXN_STATUS.ROLLBACK == transactionStatus) {

      return false;

    }

    if (openTrasactionCalls <= 0) {

      throw new RuntimeException("commitTransaction was called but openTransactionCalls = "

          + openTrasactionCalls + ". This probably indicates that there are unbalanced " +

              "calls to openTransaction/commitTransaction");

    }

    if (!currentTransaction.isActive()) {

      throw new RuntimeException(

          "Commit is called, but transaction is not active. Either there are"

              + " mismatching open and close calls or rollback was called in the same trasaction");

    }

    openTrasactionCalls--;

    if ((openTrasactionCalls == 0) && currentTransaction.isActive()) {

      transactionStatus = TXN_STATUS.COMMITED;

      currentTransaction.commit();

    }

    return true;

  }

  /**

   * @return true if there is an active transaction. If the current transaction

   *         is either committed or rolled back it returns false

   */

  public boolean isActiveTransaction() {

    if (currentTransaction == null) {

      return false;

    }

    return currentTransaction.isActive();

  }

  /**

   * Rolls back the current transaction if it is active

   */

  public void rollbackTransaction() {

    if (openTrasactionCalls < 1) {

      return;

    }

    openTrasactionCalls = 0;

    if (currentTransaction.isActive()

        && transactionStatus != TXN_STATUS.ROLLBACK) {

      transactionStatus = TXN_STATUS.ROLLBACK;

      // could already be rolled back

      currentTransaction.rollback();

    }

  }

  public void createDatabase(Database db) throws InvalidObjectException, MetaException {

    boolean commited = false;

    MDatabase mdb = new MDatabase();

    mdb.setName(db.getName().toLowerCase());

    mdb.setLocationUri(db.getLocationUri());

    mdb.setDescription(db.getDescription());

    mdb.setParameters(db.getParameters());

    try {

      openTransaction();

      pm.makePersistent(mdb);

      commited = commitTransaction();

    } finally {

      if (!commited) {

        rollbackTransaction();

      }

    }

  }

  @SuppressWarnings("nls")

  private MDatabase getMDatabase(String name) throws NoSuchObjectException {

    MDatabase mdb = null;

    boolean commited = false;

    try {

      openTransaction();

      name = name.toLowerCase().trim();

      Query query = pm.newQuery(MDatabase.class, "name == dbname");

      query.declareParameters("java.lang.String dbname");

      query.setUnique(true);

      mdb = (MDatabase) query.execute(name);

      pm.retrieve(mdb);

      commited = commitTransaction();

    } finally {

      if (!commited) {

        rollbackTransaction();

      }

    }

    if (mdb == null) {

      throw new NoSuchObjectException("There is no database named " + name);

    }

    return mdb;

  }

  public Database getDatabase(String name) throws NoSuchObjectException {

    MDatabase mdb = null;

    boolean commited = false;

    try {

      openTransaction();

      mdb = getMDatabase(name);

      commited = commitTransaction();

    } finally {

      if (!commited) {

        rollbackTransaction();

      }

    }

    Database db = new Database();

    db.setName(mdb.getName());

    db.setDescription(mdb.getDescription());

    db.setLocationUri(mdb.getLocationUri());

    db.setParameters(mdb.getParameters());

    return db;

  }

 

  /**

   * Alter the database object in metastore. Currently only the parameters

   * of the database can be changed.

   * @param dbName the database name

   * @param db the Hive Database object

   * @throws MetaException

   * @throws NoSuchObjectException

   */

  public boolean alterDatabase(String dbName, Database db)

    throws MetaException, NoSuchObjectException {

    MDatabase mdb = null;

    boolean committed = false;

    try {

      mdb = getMDatabase(dbName);

      // currently only allow changing database parameters

      mdb.setParameters(db.getParameters());

      openTransaction();

      pm.makePersistent(mdb);

      committed = commitTransaction();

    } finally {

      if (!committed) {

        rollbackTransaction();

        return false;

      }

    }

    return true;

  }

  public boolean dropDatabase(String dbname) throws NoSuchObjectException, MetaException {

    boolean success = false;

    LOG.info("Dropping database " + dbname + " along with all tables");

    dbname = dbname.toLowerCase();

    try {

      openTransaction();

      // first drop tables

      for (String tableName : getAllTables(dbname)) {

        dropTable(dbname, tableName);

      }

      // then drop the database

      MDatabase db = getMDatabase(dbname);

      pm.retrieve(db);

      if (db != null) {

        List<MDBPrivilege> dbGrants = this.listDatabaseGrants(dbname);