com.alibaba.wasp.master.handler.TruncateTableHandler.java Source code

Introduction

Here is the source code for com.alibaba.wasp.master.handler.TruncateTableHandler.java

Source

/**
 * 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.
 */
package com.alibaba.wasp.master.handler;

import com.alibaba.wasp.EntityGroupInfo;
import com.alibaba.wasp.TableLockedException;
import com.alibaba.wasp.TableNotDisabledException;
import com.alibaba.wasp.TableNotEnabledException;
import com.alibaba.wasp.TableNotFoundException;
import com.alibaba.wasp.executor.EventHandler;
import com.alibaba.wasp.master.AssignmentManager;
import com.alibaba.wasp.master.FMasterServices;
import com.alibaba.wasp.master.TableLockManager;
import com.alibaba.wasp.meta.FMetaReader;
import com.alibaba.wasp.meta.FMetaServices;
import com.alibaba.wasp.meta.FTable;
import com.alibaba.wasp.meta.Index;
import com.alibaba.wasp.meta.StorageTableNameBuilder;
import com.google.protobuf.ServiceException;
import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.HTableDescriptor;
import org.apache.hadoop.hbase.util.Bytes;
import org.apache.zookeeper.KeeperException;

import java.io.IOException;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;

/**
 * Handler to truncate a table.
 */
public class TruncateTableHandler extends EventHandler {
    private static final Log LOG = LogFactory.getLog(TruncateTableHandler.class);
    // private final AssignmentManager assignmentManager;
    private final String tableNameStr;
    private final Configuration conf;
    private TableLockManager tableLockManager;
    private byte[] table;

    public TruncateTableHandler(final byte[] tableName, FMasterServices server, AssignmentManager assignmentManager)
            throws TableNotFoundException, TableNotEnabledException, IOException {
        super(server, EventType.C_M_TRUNCATE_TABLE);
        this.table = tableName;
        this.tableNameStr = Bytes.toString(tableName);
        // this.assignmentManager = assignmentManager;
        this.conf = server.getConfiguration();
        this.tableLockManager = server.getTableLockManager();
        // Check if table exists
        if (!FMetaReader.tableExists(conf, tableNameStr)) {
            throw new TableNotFoundException(tableNameStr);
        }

        try {
            server.checkTableModifiable(tableName);
        } catch (TableNotDisabledException ex) {
            throw ex;
        }
        if (tableLockManager.lockTable(tableNameStr)) {
            LOG.info("lock table '" + tableNameStr + "' by TruncateTableHandler");
        } else {
            throw new TableLockedException(tableNameStr + " has been locked. ");
        }
    }

    @Override
    public void process() throws IOException {
        try {
            LOG.info("Attempting to truncate the table " + tableNameStr);
            handleTruncateTable(tableNameStr);
        } catch (IOException e) {
            LOG.error("Error trying to truncate the table " + tableNameStr, e);
        } catch (ServiceException e) {
            LOG.error("Error trying to truncate the table " + tableNameStr, e);
        } catch (KeeperException e) {
            LOG.error("Error trying to truncate the table " + tableNameStr, e);
        } finally {
            tableLockManager.unlockTable(tableNameStr);
        }
    }

    private void handleTruncateTable(String tableName) throws IOException, ServiceException, KeeperException {
        FMetaServices fmetaServices = FMetaReader.getService(server.getConfiguration());
        FTable ftable = FMetaReader.getTable(server.getConfiguration(), tableNameStr);
        // 1. delete storage table in HBase
        String htablename = StorageTableNameBuilder.buildEntityTableName(ftable.getTableName());
        fmetaServices.deleteStorageTable(htablename);

        // 2. create storage table in HBase
        HTableDescriptor desc = fmetaServices.getStorageTableDesc(ftable);
        fmetaServices.createStorageTable(desc);

        // 3. delete Transaction table in HBase
        List<EntityGroupInfo> eginfos = FMetaReader.getTableEntityGroups(server.getConfiguration(), table);
        for (EntityGroupInfo eginfo : eginfos) {
            String tTableName = StorageTableNameBuilder.buildTransactionTableName(eginfo.getEncodedName());
            if (fmetaServices.storageTableExists(tTableName)) {
                fmetaServices.deleteStorageTable(tTableName);
            }
        }

        // 4. clean Index table in HBase
        LinkedHashMap<String, Index> indexs = ftable.getIndex();
        Iterator<Index> iter = indexs.values().iterator();
        while (iter.hasNext()) {
            Index index = iter.next();
            String htable = StorageTableNameBuilder.buildIndexTableName(index);
            HTableDescriptor htableDesc = fmetaServices.getStorageTableDesc(htable);
            fmetaServices.deleteStorageTable(htable);
            fmetaServices.createStorageTable(htableDesc);
        }

        // unlock table
        tableLockManager.unlockTable(tableNameStr);
    }

    @Override
    public String toString() {
        String name = "UnknownServerName";
        if (server != null && server.getServerName() != null) {
            name = server.getServerName().toString();
        }
        return getClass().getSimpleName() + "-" + name + "-" + getSeqid() + "-" + tableNameStr;
    }

}