import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
/**
 * Insert a thrift audit log entry that represents renaming a partition.
 *
 * @param hmsHandler the HMSHandler for the event
 * @param oldPartition the old partition name
 * @param newPartition the new partition name
 * @param hiveConf Hive configuration
 * @throws Exception if there's an error inserting into the audit log
 */
public static void insertThriftRenamePartitionLogEntry(
    HiveMetaStore.HMSHandler hmsHandler,
    Partition oldPartition,
    Partition newPartition,
    HiveConf hiveConf) throws Exception {
  final MetastoreAuditLogListener metastoreAuditLogListener =
      new MetastoreAuditLogListener(hiveConf);

  AlterPartitionEvent event = new AlterPartitionEvent(
      oldPartition,
      newPartition,
      true,
      hmsHandler
  );

  metastoreAuditLogListener.onAlterPartition(event);
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
@Override
public void init() throws InitUnitException {
    try {
        hdfsUnit.getFileSystem().mkdirs(new Path(HIVE_HOME));
        hdfsUnit.getFileSystem().setOwner(new Path(HIVE_HOME), "hive", "hive");
    } catch (IOException e) {
        throw new InitUnitException("Failed to create hive home directory: " + HIVE_HOME, e);
    }
    metastorePort = PortProvider.nextPort();
    final HiveConf hiveConf = gatherConfigs();
    new Thread(new Runnable() {
        @Override
        public void run() {
            try {
                //TODO: remove static call
                HiveMetaStore.startMetaStore(metastorePort, null, hiveConf);
            } catch (Throwable throwable) {
                throwable.printStackTrace();
            }
        }
    }).start();
    hiveServer = new HiveServer2();
    hiveServer.init(hiveConf);
    hiveServer.start();
    jdbcUrl = String.format("jdbc:hive2://%s:%s/default", HIVE_HOST, port);
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
private void startThrift() throws Exception {
  final Lock startLock = new ReentrantLock();
  final Condition startCondition = startLock.newCondition();
  final AtomicBoolean startedServing = new AtomicBoolean();
  try (ServerSocket socket = new ServerSocket(0)) {
    thriftPort = socket.getLocalPort();
  }
  conf.setVar(ConfVars.METASTOREURIS, getThriftConnectionUri());
  final HiveConf hiveConf = new HiveConf(conf, HiveMetaStoreClient.class);
  thriftServer.execute(new Runnable() {
    @Override
    public void run() {
      try {
        HadoopThriftAuthBridge bridge = new HadoopThriftAuthBridge23();
        HiveMetaStore.startMetaStore(thriftPort, bridge, hiveConf, startLock, startCondition, startedServing);
      } catch (Throwable e) {
        LOG.error("Unable to start a Thrift server for Hive Metastore", e);
      }
    }
  });
  int i = 0;
  while (i++ < 3) {
    startLock.lock();
    try {
      if (startCondition.await(1, TimeUnit.MINUTES)) {
        break;
      }
    } finally {
      startLock.unlock();
    }
    if (i == 3) {
      throw new RuntimeException("Maximum number of tries reached whilst waiting for Thrift server to be ready");
    }
  }
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
private void simulatedRenamePartition(String dbName,
    String tableName,
    String oldPartitionName,
    List<String> newPartitionValues) throws Exception {
  Partition oldPartition = srcMetastore.getPartition(dbName, tableName, oldPartitionName);
  Partition newPartition = new Partition(oldPartition);
  newPartition.setValues(newPartitionValues);

  HiveConf hiveConf = AuditLogHookUtils.getMetastoreHiveConf(
      embeddedMySqlDb,
      AUDIT_LOG_DB_NAME,
      AUDIT_LOG_TABLE_NAME,
      AUDIT_LOG_OBJECTS_TABLE_NAME
  );

  HiveMetaStore.HMSHandler handler = Mockito.mock(HiveMetaStore.HMSHandler.class);
  Mockito.when(
      handler.get_table(dbName, tableName)
  ).thenReturn(srcMetastore.getTable(dbName, tableName));

  AuditLogHookUtils.insertThriftRenamePartitionLogEntry(
      handler,
      oldPartition,
      newPartition,
      hiveConf
  );
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
@Override
public void run() {
    try {
        HiveMetaStore.startMetaStore(hiveMetastorePort, 
                new HadoopThriftAuthBridge(), 
                hiveConf);
    } catch (Throwable t) {
        t.printStackTrace();
    }
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
@Override
public void start() throws IOException {
  final HiveConf serverConf = new HiveConf(new Configuration(), this.getClass());
  serverConf.set("hive.metastore.local", "false");
  serverConf.set(HiveConf.ConfVars.METASTORECONNECTURLKEY.varname, "jdbc:derby:target/metastore_db;create=true");
  //serverConf.set(HiveConf.ConfVars.METASTORE_EVENT_LISTENERS.varname, NotificationListener.class.getName());
  File derbyLogFile = new File("target/derby.log");
  derbyLogFile.createNewFile();
  setSystemProperty("derby.stream.error.file", derbyLogFile.getPath());
  serverThread = new Thread(new Runnable() {
    @Override
    public void run() {
      try {
        HiveMetaStore.startMetaStore(9083, ShimLoader.getHadoopThriftAuthBridge(),
            serverConf);
        //LOG.info("Started metastore server on port " + msPort);
      }
      catch (Throwable e) {
        //LOG.error("Metastore Thrift Server threw an exception...", e);
      }
    }
  });
  serverThread.setDaemon(true);
  serverThread.start();
  try {
    Thread.sleep(10000L);
  } catch (InterruptedException e) {
    // do nothing
  }
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
private void startMetastore() throws Exception {
  Callable<Void> metastoreService = new Callable<Void>() {
    public Void call() throws Exception {
      try {
        HiveMetaStore.startMetaStore(getMetastorePort(conf),
            ShimLoader.getHadoopThriftAuthBridge(), conf);
      } catch (Throwable e) {
        throw new Exception("Error starting metastore", e);
      }
      return null;
    }
  };
  metaStoreExecutor.submit(metastoreService);
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
@Override
public void start() {
  // Fix for ACCESS-148. Resets a static field
  // so the default database is created even
  // though is has been created before in this JVM
  Reflection.staticField("createDefaultDB")
  .ofType(boolean.class)
  .in(HiveMetaStore.HMSHandler.class)
  .set(false);
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
/**
 * Start all required mini clusters.
 */
@BeforeClass
public static void setUpClass() throws Exception {
  // Conf dir
  if (!new File(confDir).mkdirs()) {
    fail("Failed to create config directories.");
  }

  // HDFS
  File minidfsDir = new File("target/minidfs").getAbsoluteFile();
  if (!minidfsDir.exists()) {
    Assert.assertTrue(minidfsDir.mkdirs());
  }
  Set<PosixFilePermission> set = new HashSet<>();
  set.add(PosixFilePermission.OWNER_EXECUTE);
  set.add(PosixFilePermission.OWNER_READ);
  set.add(PosixFilePermission.OWNER_WRITE);
  set.add(PosixFilePermission.OTHERS_READ);
  java.nio.file.Files.setPosixFilePermissions(minidfsDir.toPath(), set);
  System.setProperty(MiniDFSCluster.PROP_TEST_BUILD_DATA, minidfsDir.getPath());
  final Configuration conf = new HdfsConfiguration();
  conf.set("hadoop.proxyuser." + System.getProperty("user.name") + ".hosts", "*");
  conf.set("hadoop.proxyuser." + System.getProperty("user.name") + ".groups", "*");
  miniDFS = new MiniDFSCluster.Builder(conf).build();
  miniDFS.getFileSystem().setPermission(new Path("/"), FsPermission.createImmutable((short)0777));
  miniMR = MiniMRClientClusterFactory.create(BaseHiveIT.class, 1, conf);
  writeConfiguration(miniMR.getConfig(), confDir + "/core-site.xml");
  writeConfiguration(miniMR.getConfig(), confDir + "/hdfs-site.xml");
  writeConfiguration(miniMR.getConfig(), confDir + "/mapred-site.xml");
  writeConfiguration(miniMR.getConfig(), confDir + "/yarn-site.xml");

  // Configuration for both HMS and HS2
  METASTORE_PORT = NetworkUtils.getRandomPort();
  HIVE_SERVER_PORT = NetworkUtils.getRandomPort();
  final HiveConf hiveConf = new HiveConf(miniDFS.getConfiguration(0), HiveConf.class);
  hiveConf.set(HiveConf.ConfVars.METASTORECONNECTURLKEY.varname, "jdbc:derby:;databaseName=target/metastore_db;create=true");
  hiveConf.set(HiveConf.ConfVars.METASTOREURIS.varname, Utils.format("thrift://{}:{}", HOSTNAME, METASTORE_PORT));
  hiveConf.set(HiveConf.ConfVars.HIVE_SERVER2_THRIFT_BIND_HOST.varname, "localhost");
  hiveConf.set("org.jpox.autoCreateSchema", "true");
  hiveConf.set("datanucleus.schema.autoCreateTables", "true");
  hiveConf.set("hive.metastore.schema.verification", "false");
  hiveConf.setInt(HiveConf.ConfVars.HIVE_SERVER2_THRIFT_PORT.varname, HIVE_SERVER_PORT);

  // Hive metastore
  Callable<Void> metastoreService = () -> {
    try {
      HiveMetaStore.startMetaStore(METASTORE_PORT, ShimLoader.getHadoopThriftAuthBridge(), hiveConf);
      while(true);
    } catch (Throwable e) {
      throw new Exception("Error starting metastore", e);
    }
  };
  hiveMetastoreExecutor.submit(metastoreService);
  NetworkUtils.waitForStartUp(HOSTNAME, METASTORE_PORT, MINICLUSTER_BOOT_RETRY, MINICLUSTER_BOOT_SLEEP);

  // HiveServer 2
  hiveServer2 = new HiveServer2();
  hiveServer2.init(hiveConf);
  hiveServer2.start();
  writeConfiguration(hiveServer2.getHiveConf(), confDir + "/hive-site.xml");
  NetworkUtils.waitForStartUp(HOSTNAME, HIVE_SERVER_PORT, MINICLUSTER_BOOT_RETRY, MINICLUSTER_BOOT_SLEEP);

  // JDBC Connection to Hive
  Class.forName(HIVE_JDBC_DRIVER);
  hiveConnection = HiveMetastoreUtil.getHiveConnection(
    getHiveJdbcUrl(),
    HadoopSecurityUtil.getLoginUser(conf),
    Collections.emptyList()
  );

  // And finally we're initialized
  isHiveInitialized = true;
}
 

import org.apache.hadoop.hive.metastore.HiveMetaStore; //导入依赖的package包/类
/**
 * Constructor.
 *
 * @param name client name
 * @throws MetaException exception
 */
public MetacatHMSHandler(final String name) throws MetaException {
    this(name, new HiveConf(HiveMetaStore.HMSHandler.class));
}