org.apache.hadoop.hbase.coprocessor.MasterObserver Java Examples

private List<MasterObserver> getAccessControllers() throws IOException {
    ArrayList<MasterObserver> oldAccessControllers = accessControllers.get();
    if (oldAccessControllers == null) {
        oldAccessControllers = new ArrayList<>();
        RegionCoprocessorHost cpHost = this.env.getCoprocessorHost();
        for (RegionCoprocessor cp : cpHost.findCoprocessors(RegionCoprocessor.class)) {
            if (cp instanceof AccessControlService.Interface && cp instanceof MasterObserver) {
                oldAccessControllers.add((MasterObserver)cp);
                if(cp.getClass().getName().equals(org.apache.hadoop.hbase.security.access.AccessController.class.getName())) {
                    hbaseAccessControllerEnabled = true;
                }
            }
        }
        accessControllers.set(oldAccessControllers);
    }
    return accessControllers.get();
}
 

public void preStopMaster() throws IOException {
  // While stopping master all coprocessors method should be executed first then the coprocessor
  // environment should be cleaned up.
  if (coprocEnvironments.isEmpty()) {
    return;
  }
  execShutdown(new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preStopMaster(this);
    }
    @Override
    public void postEnvCall() {
      // invoke coprocessor stop method
      shutdown(this.getEnvironment());
    }
  });
}
 

@Override
public void preIndexUpdate(ObserverContext<PhoenixMetaDataControllerEnvironment> ctx, String tenantId,
        String indexName, TableName physicalTableName, TableName parentPhysicalTableName, PIndexState newState)
        throws IOException {
    if (!accessCheckEnabled) { return; }
    for (MasterObserver observer : getAccessControllers()) {
        observer.preModifyTable(getMasterObsevrverContext(), physicalTableName,
                TableDescriptorBuilder.newBuilder(physicalTableName).build());
    }
    // Check for read access in case of rebuild
    if (newState == PIndexState.BUILDING) {
        if(execPermissionsCheckEnabled) {
            requireAccess("Rebuild:", parentPhysicalTableName, Action.READ, Action.EXEC);
        } else {
            requireAccess("Rebuild:", parentPhysicalTableName, Action.READ);
        }
    }
}
 

@Override
public void preAlterTable(ObserverContext<PhoenixMetaDataControllerEnvironment> ctx, String tenantId,
        String tableName, TableName physicalTableName, TableName parentPhysicalTableName, PTableType tableType) throws IOException {
    if (!accessCheckEnabled) { return; }
    for (MasterObserver observer : getAccessControllers()) {
        if (tableType != PTableType.VIEW) {
        observer.preModifyTable(getMasterObsevrverContext(), physicalTableName,
                TableDescriptorBuilder.newBuilder(physicalTableName).build());
        }
    }
    if (tableType == PTableType.VIEW) {
        if(execPermissionsCheckEnabled) {
            requireAccess("Alter "+tableType, parentPhysicalTableName, Action.READ, Action.EXEC);
        } else {
            requireAccess("Alter "+tableType, parentPhysicalTableName, Action.READ);
        }
    }
}
 

public void preMoveServersAndTables(final Set<Address> servers, final Set<TableName> tables,
    final String targetGroup) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preMoveServersAndTables(this, servers, tables, targetGroup);
    }
  });
}
 

public void postAssign(final RegionInfo regionInfo) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postAssign(this, regionInfo);
    }
  });
}
 

public void preBalanceRSGroup(final String name)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preBalanceRSGroup(this, name);
    }
  });
}
 

public void preSetUserQuota(
    final String user, final TableName table, final GlobalQuotaSettings quotas)
        throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preSetUserQuota(this, user, table, quotas);
    }
  });
}
 

public void postGetUserPermissions(String userName, String namespace, TableName tableName,
    byte[] family, byte[] qualifier) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postGetUserPermissions(this, userName, namespace, tableName, family, qualifier);
    }
  });
}
 

public void postGetRSGroupInfoOfTable(final TableName tableName) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postGetRSGroupInfoOfTable(this, tableName);
    }
  });
}
 

public void preDecommissionRegionServers(List<ServerName> servers, boolean offload)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preDecommissionRegionServers(this, servers, offload);
    }
  });
}
 

public void postGetRSGroupInfo(final String groupName) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postGetRSGroupInfo(this, groupName);
    }
  });
}
 

public void preIsRpcThrottleEnabled() throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preIsRpcThrottleEnabled(this);
    }
  });
}
 

public void preHasUserPermissions(String userName, List<Permission> permissions)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preHasUserPermissions(this, userName, permissions);
    }
  });
}
 

public void postClearDeadServers(List<ServerName> servers,
    List<ServerName> notClearedServers) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postClearDeadServers(this, servers, notClearedServers);
    }
  });
}
 

public void preUpdateReplicationPeerConfig(final String peerId,
    final ReplicationPeerConfig peerConfig) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preUpdateReplicationPeerConfig(this, peerId, peerConfig);
    }
  });
}
 

/**
 * This will be called before update META step as part of split table region procedure.
 * @param splitKey
 * @param metaEntries
 * @param user the user
 * @throws IOException
 */
public void preSplitBeforeMETAAction(
    final byte[] splitKey,
    final List<Mutation> metaEntries,
    final User user) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation(user) {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preSplitRegionBeforeMETAAction(this, splitKey, metaEntries);
    }
  });
}
 

public void preGetConfiguredNamespacesAndTablesInRSGroup(final String groupName)
  throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {

    @Override
    protected void call(MasterObserver observer) throws IOException {
      observer.preGetConfiguredNamespacesAndTablesInRSGroup(this, groupName);
    }
  });
}
 

public void postRemoveServers(final Set<Address> servers)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postRemoveServers(this, servers);
    }
  });
}
 

public void preSwitchRpcThrottle(boolean enable) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null :new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preSwitchRpcThrottle(this, enable);
    }
  });
}
 

public void preAddReplicationPeer(final String peerId, final ReplicationPeerConfig peerConfig)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preAddReplicationPeer(this, peerId, peerConfig);
    }
  });
}
 

public void postGetProcedures(final List<Procedure<?>> procInfoList) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postGetProcedures(this);
    }
  });
}
 

public void postRemoveRSGroup(final String name)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postRemoveRSGroup(this, name);
    }
  });
}
 

public void preDeleteSnapshot(final SnapshotDescription snapshot) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preDeleteSnapshot(this, snapshot);
    }
  });
}
 

public void preAbortProcedure(
    final ProcedureExecutor<MasterProcedureEnv> procEnv,
    final long procId) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preAbortProcedure(this,  procId);
    }
  });
}
 

public void postRecommissionRegionServer(ServerName server, List<byte[]> encodedRegionNames)
    throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postRecommissionRegionServer(this, server, encodedRegionNames);
    }
  });
}
 

public void preDisableTableAction(final TableName tableName, final User user) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation(user) {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preDisableTableAction(this, tableName);
    }
  });
}
 

public void postDisableTable(final TableName tableName) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postDisableTable(this, tableName);
    }
  });
}
 

public void preListDecommissionedRegionServers() throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.preListDecommissionedRegionServers(this);
    }
  });
}
 

public void postCompletedSnapshotAction(SnapshotDescription snapshot,
    TableDescriptor hTableDescriptor) throws IOException {
  execOperation(coprocEnvironments.isEmpty() ? null : new MasterObserverOperation() {
    @Override
    public void call(MasterObserver observer) throws IOException {
      observer.postCompletedSnapshotAction(this, snapshot, hTableDescriptor);
    }
  });
}