View Javadoc

1   /**
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   *     http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing, software
13   * distributed under the License is distributed on an "AS IS" BASIS,
14   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15   * See the License for the specific language governing permissions and
16   * limitations under the License.
17   */
18  
19  package org.apache.hadoop.hbase.master.procedure;
20  
21  import java.io.InputStream;
22  import java.io.IOException;
23  import java.io.OutputStream;
24  import java.security.PrivilegedExceptionAction;
25  import java.util.ArrayList;
26  import java.util.List;
27  
28  import org.apache.commons.logging.Log;
29  import org.apache.commons.logging.LogFactory;
30  import org.apache.hadoop.hbase.classification.InterfaceAudience;
31  import org.apache.hadoop.fs.FileSystem;
32  import org.apache.hadoop.fs.FileStatus;
33  import org.apache.hadoop.fs.Path;
34  import org.apache.hadoop.hbase.TableName;
35  import org.apache.hadoop.hbase.TableNotDisabledException;
36  import org.apache.hadoop.hbase.TableNotFoundException;
37  import org.apache.hadoop.hbase.HRegionInfo;
38  import org.apache.hadoop.hbase.backup.HFileArchiver;
39  import org.apache.hadoop.hbase.MetaTableAccessor;
40  import org.apache.hadoop.hbase.client.ClusterConnection;
41  import org.apache.hadoop.hbase.client.Delete;
42  import org.apache.hadoop.hbase.client.Result;
43  import org.apache.hadoop.hbase.client.ResultScanner;
44  import org.apache.hadoop.hbase.client.Scan;
45  import org.apache.hadoop.hbase.client.Table;
46  import org.apache.hadoop.hbase.exceptions.HBaseException;
47  import org.apache.hadoop.hbase.regionserver.HRegion;
48  import org.apache.hadoop.hbase.master.AssignmentManager;
49  import org.apache.hadoop.hbase.master.MasterCoprocessorHost;
50  import org.apache.hadoop.hbase.master.MasterFileSystem;
51  import org.apache.hadoop.hbase.protobuf.generated.HBaseProtos;
52  import org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos;
53  import org.apache.hadoop.hbase.protobuf.generated.MasterProcedureProtos.DeleteTableState;
54  import org.apache.hadoop.hbase.protobuf.ProtobufUtil;
55  import org.apache.hadoop.hbase.procedure2.StateMachineProcedure;
56  import org.apache.hadoop.hbase.util.FSUtils;
57  import org.apache.hadoop.security.UserGroupInformation;
58  
59  @InterfaceAudience.Private
60  public class DeleteTableProcedure
61      extends StateMachineProcedure<MasterProcedureEnv, DeleteTableState>
62      implements TableProcedureInterface {
63    private static final Log LOG = LogFactory.getLog(DeleteTableProcedure.class);
64  
65    private List<HRegionInfo> regions;
66    private UserGroupInformation user;
67    private TableName tableName;
68  
69    // used for compatibility with old clients
70    private final ProcedurePrepareLatch syncLatch;
71  
72    public DeleteTableProcedure() {
73      // Required by the Procedure framework to create the procedure on replay
74      syncLatch = null;
75    }
76  
77    public DeleteTableProcedure(final MasterProcedureEnv env, final TableName tableName)
78        throws IOException {
79      this(env, tableName, null);
80    }
81  
82    public DeleteTableProcedure(final MasterProcedureEnv env, final TableName tableName,
83        final ProcedurePrepareLatch syncLatch) throws IOException {
84      this.tableName = tableName;
85      this.user = env.getRequestUser().getUGI();
86      this.setOwner(this.user.getShortUserName());
87  
88      // used for compatibility with clients without procedures
89      // they need a sync TableNotFoundException, TableNotDisabledException, ...
90      this.syncLatch = syncLatch;
91    }
92  
93    @Override
94    protected Flow executeFromState(final MasterProcedureEnv env, DeleteTableState state)
95        throws InterruptedException {
96      if (LOG.isTraceEnabled()) {
97        LOG.trace(this + " execute state=" + state);
98      }
99      try {
100       switch (state) {
101         case DELETE_TABLE_PRE_OPERATION:
102           // Verify if we can delete the table
103           boolean deletable = prepareDelete(env);
104           ProcedurePrepareLatch.releaseLatch(syncLatch, this);
105           if (!deletable) {
106             assert isFailed() : "the delete should have an exception here";
107             return Flow.NO_MORE_STATE;
108           }
109 
110           // TODO: Move out... in the acquireLock()
111           LOG.debug("waiting for '" + getTableName() + "' regions in transition");
112           regions = ProcedureSyncWait.getRegionsFromMeta(env, getTableName());
113           assert regions != null && !regions.isEmpty() : "unexpected 0 regions";
114           ProcedureSyncWait.waitRegionInTransition(env, regions);
115 
116           // Call coprocessors
117           preDelete(env);
118 
119           setNextState(DeleteTableState.DELETE_TABLE_REMOVE_FROM_META);
120           break;
121         case DELETE_TABLE_REMOVE_FROM_META:
122           LOG.debug("delete '" + getTableName() + "' regions from META");
123           DeleteTableProcedure.deleteFromMeta(env, getTableName(), regions);
124           setNextState(DeleteTableState.DELETE_TABLE_CLEAR_FS_LAYOUT);
125           break;
126         case DELETE_TABLE_CLEAR_FS_LAYOUT:
127           LOG.debug("delete '" + getTableName() + "' from filesystem");
128           DeleteTableProcedure.deleteFromFs(env, getTableName(), regions, true);
129           setNextState(DeleteTableState.DELETE_TABLE_UPDATE_DESC_CACHE);
130           regions = null;
131           break;
132         case DELETE_TABLE_UPDATE_DESC_CACHE:
133           LOG.debug("delete '" + getTableName() + "' descriptor");
134           DeleteTableProcedure.deleteTableDescriptorCache(env, getTableName());
135           setNextState(DeleteTableState.DELETE_TABLE_UNASSIGN_REGIONS);
136           break;
137         case DELETE_TABLE_UNASSIGN_REGIONS:
138           LOG.debug("delete '" + getTableName() + "' assignment state");
139           DeleteTableProcedure.deleteAssignmentState(env, getTableName());
140           setNextState(DeleteTableState.DELETE_TABLE_POST_OPERATION);
141           break;
142         case DELETE_TABLE_POST_OPERATION:
143           postDelete(env);
144           LOG.debug("delete '" + getTableName() + "' completed");
145           return Flow.NO_MORE_STATE;
146         default:
147           throw new UnsupportedOperationException("unhandled state=" + state);
148       }
149     } catch (HBaseException|IOException e) {
150       LOG.warn("Retriable error trying to delete table=" + getTableName() + " state=" + state, e);
151     }
152     return Flow.HAS_MORE_STATE;
153   }
154 
155   @Override
156   protected void rollbackState(final MasterProcedureEnv env, final DeleteTableState state) {
157     if (state == DeleteTableState.DELETE_TABLE_PRE_OPERATION) {
158       // nothing to rollback, pre-delete is just table-state checks.
159       // We can fail if the table does not exist or is not disabled.
160       ProcedurePrepareLatch.releaseLatch(syncLatch, this);
161       return;
162     }
163 
164     // The delete doesn't have a rollback. The execution will succeed, at some point.
165     throw new UnsupportedOperationException("unhandled state=" + state);
166   }
167 
168   @Override
169   protected DeleteTableState getState(final int stateId) {
170     return DeleteTableState.valueOf(stateId);
171   }
172 
173   @Override
174   protected int getStateId(final DeleteTableState state) {
175     return state.getNumber();
176   }
177 
178   @Override
179   protected DeleteTableState getInitialState() {
180     return DeleteTableState.DELETE_TABLE_PRE_OPERATION;
181   }
182 
183   @Override
184   public TableName getTableName() {
185     return tableName;
186   }
187 
188   @Override
189   public TableOperationType getTableOperationType() {
190     return TableOperationType.DELETE;
191   }
192 
193   @Override
194   public boolean abort(final MasterProcedureEnv env) {
195     // TODO: We may be able to abort if the procedure is not started yet.
196     return false;
197   }
198 
199   @Override
200   protected boolean acquireLock(final MasterProcedureEnv env) {
201     if (env.waitInitialized(this)) return false;
202     return env.getProcedureQueue().tryAcquireTableExclusiveLock(this, getTableName());
203   }
204 
205   @Override
206   protected void releaseLock(final MasterProcedureEnv env) {
207     env.getProcedureQueue().releaseTableExclusiveLock(this, getTableName());
208   }
209 
210   @Override
211   public void toStringClassDetails(StringBuilder sb) {
212     sb.append(getClass().getSimpleName());
213     sb.append(" (table=");
214     sb.append(getTableName());
215     sb.append(")");
216   }
217 
218   @Override
219   public void serializeStateData(final OutputStream stream) throws IOException {
220     super.serializeStateData(stream);
221 
222     MasterProcedureProtos.DeleteTableStateData.Builder state =
223       MasterProcedureProtos.DeleteTableStateData.newBuilder()
224         .setUserInfo(MasterProcedureUtil.toProtoUserInfo(this.user))
225         .setTableName(ProtobufUtil.toProtoTableName(tableName));
226     if (regions != null) {
227       for (HRegionInfo hri: regions) {
228         state.addRegionInfo(HRegionInfo.convert(hri));
229       }
230     }
231     state.build().writeDelimitedTo(stream);
232   }
233 
234   @Override
235   public void deserializeStateData(final InputStream stream) throws IOException {
236     super.deserializeStateData(stream);
237 
238     MasterProcedureProtos.DeleteTableStateData state =
239       MasterProcedureProtos.DeleteTableStateData.parseDelimitedFrom(stream);
240     user = MasterProcedureUtil.toUserInfo(state.getUserInfo());
241     tableName = ProtobufUtil.toTableName(state.getTableName());
242     if (state.getRegionInfoCount() == 0) {
243       regions = null;
244     } else {
245       regions = new ArrayList<HRegionInfo>(state.getRegionInfoCount());
246       for (HBaseProtos.RegionInfo hri: state.getRegionInfoList()) {
247         regions.add(HRegionInfo.convert(hri));
248       }
249     }
250   }
251 
252   private boolean prepareDelete(final MasterProcedureEnv env) throws IOException {
253     try {
254       env.getMasterServices().checkTableModifiable(tableName);
255     } catch (TableNotFoundException|TableNotDisabledException e) {
256       setFailure("master-delete-table", e);
257       return false;
258     }
259     return true;
260   }
261 
262   private boolean preDelete(final MasterProcedureEnv env)
263       throws IOException, InterruptedException {
264     final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
265     if (cpHost != null) {
266       final TableName tableName = this.tableName;
267       user.doAs(new PrivilegedExceptionAction<Void>() {
268         @Override
269         public Void run() throws Exception {
270           cpHost.preDeleteTableHandler(tableName);
271           return null;
272         }
273       });
274     }
275     return true;
276   }
277 
278   private void postDelete(final MasterProcedureEnv env)
279       throws IOException, InterruptedException {
280     deleteTableStates(env, tableName);
281 
282     final MasterCoprocessorHost cpHost = env.getMasterCoprocessorHost();
283     if (cpHost != null) {
284       final TableName tableName = this.tableName;
285       user.doAs(new PrivilegedExceptionAction<Void>() {
286         @Override
287         public Void run() throws Exception {
288           cpHost.postDeleteTableHandler(tableName);
289           return null;
290         }
291       });
292     }
293   }
294 
295   protected static void deleteFromFs(final MasterProcedureEnv env,
296       final TableName tableName, final List<HRegionInfo> regions,
297       final boolean archive) throws IOException {
298     final MasterFileSystem mfs = env.getMasterServices().getMasterFileSystem();
299     final FileSystem fs = mfs.getFileSystem();
300     final Path tempdir = mfs.getTempDir();
301 
302     final Path tableDir = FSUtils.getTableDir(mfs.getRootDir(), tableName);
303     final Path tempTableDir = FSUtils.getTableDir(tempdir, tableName);
304 
305     if (fs.exists(tableDir)) {
306       // Ensure temp exists
307       if (!fs.exists(tempdir) && !fs.mkdirs(tempdir)) {
308         throw new IOException("HBase temp directory '" + tempdir + "' creation failure.");
309       }
310 
311       // Ensure parent exists
312       if (!fs.exists(tempTableDir.getParent()) && !fs.mkdirs(tempTableDir.getParent())) {
313         throw new IOException("HBase temp directory '" + tempdir + "' creation failure.");
314       }
315 
316       // Move the table in /hbase/.tmp
317       if (!fs.rename(tableDir, tempTableDir)) {
318         if (fs.exists(tempTableDir)) {
319           // TODO
320           // what's in this dir? something old? probably something manual from the user...
321           // let's get rid of this stuff...
322           FileStatus[] files = fs.listStatus(tempdir);
323           if (files != null && files.length > 0) {
324             for (int i = 0; i < files.length; ++i) {
325               if (!files[i].isDir()) continue;
326               HFileArchiver.archiveRegion(fs, mfs.getRootDir(), tempTableDir, files[i].getPath());
327             }
328           }
329           fs.delete(tempdir, true);
330         }
331         throw new IOException("Unable to move '" + tableDir + "' to temp '" + tempTableDir + "'");
332       }
333     }
334 
335     // Archive regions from FS (temp directory)
336     if (archive) {
337       for (HRegionInfo hri : regions) {
338         LOG.debug("Archiving region " + hri.getRegionNameAsString() + " from FS");
339         HFileArchiver.archiveRegion(fs, mfs.getRootDir(),
340             tempTableDir, HRegion.getRegionDir(tempTableDir, hri.getEncodedName()));
341       }
342       LOG.debug("Table '" + tableName + "' archived!");
343     }
344 
345     // Delete table directory from FS (temp directory)
346     if (!fs.delete(tempTableDir, true) && fs.exists(tempTableDir)) {
347       throw new IOException("Couldn't delete " + tempTableDir);
348     }
349   }
350 
351   /**
352    * There may be items for this table still up in hbase:meta in the case where the
353    * info:regioninfo column was empty because of some write error. Remove ALL rows from hbase:meta
354    * that have to do with this table. See HBASE-12980.
355    * @throws IOException
356    */
357   private static void cleanAnyRemainingRows(final MasterProcedureEnv env,
358       final TableName tableName) throws IOException {
359     ClusterConnection connection = env.getMasterServices().getConnection();
360     Scan tableScan = MetaTableAccessor.getScanForTableName(tableName);
361     try (Table metaTable =
362         connection.getTable(TableName.META_TABLE_NAME)) {
363       List<Delete> deletes = new ArrayList<Delete>();
364       try (ResultScanner resScanner = metaTable.getScanner(tableScan)) {
365         for (Result result : resScanner) {
366           deletes.add(new Delete(result.getRow()));
367         }
368       }
369       if (!deletes.isEmpty()) {
370         LOG.warn("Deleting some vestigal " + deletes.size() + " rows of " + tableName +
371           " from " + TableName.META_TABLE_NAME);
372         metaTable.delete(deletes);
373       }
374     }
375   }
376 
377   protected static void deleteFromMeta(final MasterProcedureEnv env,
378       final TableName tableName, List<HRegionInfo> regions) throws IOException {
379     MetaTableAccessor.deleteRegions(env.getMasterServices().getConnection(), regions);
380 
381     // Clean any remaining rows for this table.
382     cleanAnyRemainingRows(env, tableName);
383   }
384 
385   protected static void deleteAssignmentState(final MasterProcedureEnv env,
386       final TableName tableName) throws HBaseException, IOException {
387     AssignmentManager am = env.getMasterServices().getAssignmentManager();
388 
389     // Clean up regions of the table in RegionStates.
390     LOG.debug("Removing '" + tableName + "' from region states.");
391     am.getRegionStates().tableDeleted(tableName);
392 
393     // If entry for this table states, remove it.
394     LOG.debug("Marking '" + tableName + "' as deleted.");
395     am.getTableStateManager().setDeletedTable(tableName);
396   }
397 
398   protected static void deleteTableDescriptorCache(final MasterProcedureEnv env,
399       final TableName tableName) throws IOException {
400     LOG.debug("Removing '" + tableName + "' descriptor.");
401     env.getMasterServices().getTableDescriptors().remove(tableName);
402   }
403 
404   protected static void deleteTableStates(final MasterProcedureEnv env, final TableName tableName)
405       throws IOException {
406     if (!tableName.isSystemTable()) {
407       ProcedureSyncWait.getMasterQuotaManager(env).removeTableFromNamespaceQuota(tableName);
408     }
409   }
410 }