1 /**
2 *
3 * Licensed to the Apache Software Foundation (ASF) under one
4 * or more contributor license agreements. See the NOTICE file
5 * distributed with this work for additional information
6 * regarding copyright ownership. The ASF licenses this file
7 * to you under the Apache License, Version 2.0 (the
8 * "License"); you may not use this file except in compliance
9 * with the License. You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 */
19 package org.apache.hadoop.hbase.master;
20
21 import java.io.IOException;
22 import java.util.List;
23 import java.util.concurrent.Future;
24
25 import org.apache.hadoop.hbase.backup.BackupType;
26 import org.apache.hadoop.hbase.classification.InterfaceAudience;
27 import org.apache.hadoop.hbase.HColumnDescriptor;
28 import org.apache.hadoop.hbase.HRegionInfo;
29 import org.apache.hadoop.hbase.HTableDescriptor;
30 import org.apache.hadoop.hbase.NamespaceDescriptor;
31 import org.apache.hadoop.hbase.ProcedureInfo;
32 import org.apache.hadoop.hbase.Server;
33 import org.apache.hadoop.hbase.TableDescriptors;
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.TableStateManager;
38 import org.apache.hadoop.hbase.master.procedure.MasterProcedureEnv;
39 import org.apache.hadoop.hbase.master.snapshot.SnapshotManager;
40 import org.apache.hadoop.hbase.procedure.MasterProcedureManagerHost;
41 import org.apache.hadoop.hbase.procedure2.ProcedureExecutor;
42 import org.apache.hadoop.hbase.executor.ExecutorService;
43 import org.apache.hadoop.hbase.quotas.MasterQuotaManager;
44 import org.apache.hadoop.hbase.util.Pair;
45
46 import com.google.protobuf.Service;
47
48 /**
49 * Services Master supplies
50 */
51 @InterfaceAudience.Private
52 public interface MasterServices extends Server {
53 /**
54 * @return the underlying snapshot manager
55 */
56 SnapshotManager getSnapshotManager();
57
58 /**
59 * @return the underlying MasterProcedureManagerHost
60 */
61 MasterProcedureManagerHost getMasterProcedureManagerHost();
62
63 /**
64 * @return Master's instance of the {@link AssignmentManager}
65 */
66 AssignmentManager getAssignmentManager();
67
68 /**
69 * @return Master's filesystem {@link MasterFileSystem} utility class.
70 */
71 MasterFileSystem getMasterFileSystem();
72
73 /**
74 * @return Master's {@link ServerManager} instance.
75 */
76 ServerManager getServerManager();
77
78 /**
79 * @return Master's instance of {@link ExecutorService}
80 */
81 ExecutorService getExecutorService();
82
83 /**
84 * @return Master's instance of {@link TableLockManager}
85 */
86 TableLockManager getTableLockManager();
87
88 /**
89 * @return Master's instance of {@link MasterCoprocessorHost}
90 */
91 MasterCoprocessorHost getMasterCoprocessorHost();
92
93 /**
94 * @return Master's instance of {@link MasterQuotaManager}
95 */
96 MasterQuotaManager getMasterQuotaManager();
97
98 /**
99 * @return Master's instance of {@link ProcedureExecutor}
100 */
101 ProcedureExecutor<MasterProcedureEnv> getMasterProcedureExecutor();
102
103 /**
104 * Check table is modifiable; i.e. exists and is offline.
105 * @param tableName Name of table to check.
106 * @throws TableNotDisabledException
107 * @throws TableNotFoundException
108 * @throws IOException
109 */
110 // We actually throw the exceptions mentioned in the
111 void checkTableModifiable(final TableName tableName)
112 throws IOException, TableNotFoundException, TableNotDisabledException;
113
114 /**
115 * Check whether the procedure executor is enabled
116 */
117 boolean isMasterProcedureExecutorEnabled();
118
119 /**
120 * Create a table using the given table definition.
121 * @param desc The table definition
122 * @param splitKeys Starting row keys for the initial table regions. If null
123 * a single region is created.
124 */
125 long createTable(HTableDescriptor desc, byte[][] splitKeys)
126 throws IOException;
127
128 /**
129 * Delete a table
130 * @param tableName The table name
131 * @throws IOException
132 */
133 long deleteTable(final TableName tableName) throws IOException;
134
135 /**
136 * Truncate a table
137 * @param tableName The table name
138 * @param preserveSplits True if the splits should be preserved
139 * @throws IOException
140 */
141 public void truncateTable(final TableName tableName, boolean preserveSplits) throws IOException;
142
143 /**
144 * Modify the descriptor of an existing table
145 * @param tableName The table name
146 * @param descriptor The updated table descriptor
147 * @throws IOException
148 */
149 void modifyTable(final TableName tableName, final HTableDescriptor descriptor)
150 throws IOException;
151
152 /**
153 * Full backup given list of tables
154 * @param type whether the backup is full or incremental
155 * @param tableList list of tables to backup
156 * @param targetRootDir root dir for saving the backup
157 * @param workers number of paralle workers. -1 - system defined
158 * @param bandwidth bandwidth per worker in MB per sec. -1 - unlimited
159 * @return pair of procedure Id and backupId
160 * @throws IOException
161 */
162 public Pair<Long, String> backupTables(
163 final BackupType type,
164 List<TableName> tableList,
165 final String targetRootDir,
166 final int workers,
167 final long bandwidth) throws IOException;
168
169 /**
170 * Enable an existing table
171 * @param tableName The table name
172 * @throws IOException
173 */
174 long enableTable(final TableName tableName) throws IOException;
175
176 /**
177 * Disable an existing table
178 * @param tableName The table name
179 * @throws IOException
180 */
181 long disableTable(final TableName tableName) throws IOException;
182
183
184 /**
185 * Add a new column to an existing table
186 * @param tableName The table name
187 * @param column The column definition
188 * @throws IOException
189 */
190 void addColumn(final TableName tableName, final HColumnDescriptor column)
191 throws IOException;
192
193 /**
194 * Modify the column descriptor of an existing column in an existing table
195 * @param tableName The table name
196 * @param descriptor The updated column definition
197 * @throws IOException
198 */
199 void modifyColumn(TableName tableName, HColumnDescriptor descriptor)
200 throws IOException;
201
202 /**
203 * Delete a column from an existing table
204 * @param tableName The table name
205 * @param columnName The column name
206 * @throws IOException
207 */
208 void deleteColumn(final TableName tableName, final byte[] columnName)
209 throws IOException;
210
211 /**
212 * @return Return table descriptors implementation.
213 */
214 TableDescriptors getTableDescriptors();
215
216 /**
217 * @return true if master enables ServerShutdownHandler;
218 */
219 boolean isServerShutdownHandlerEnabled();
220
221 /**
222 * Registers a new protocol buffer {@link Service} subclass as a master coprocessor endpoint.
223 *
224 * <p>
225 * Only a single instance may be registered for a given {@link Service} subclass (the
226 * instances are keyed on {@link com.google.protobuf.Descriptors.ServiceDescriptor#getFullName()}.
227 * After the first registration, subsequent calls with the same service name will fail with
228 * a return value of {@code false}.
229 * </p>
230 * @param instance the {@code Service} subclass instance to expose as a coprocessor endpoint
231 * @return {@code true} if the registration was successful, {@code false}
232 * otherwise
233 */
234 boolean registerService(Service instance);
235
236 /**
237 * Merge two regions. The real implementation is on the regionserver, master
238 * just move the regions together and send MERGE RPC to regionserver
239 * @param region_a region to merge
240 * @param region_b region to merge
241 * @param forcible true if do a compulsory merge, otherwise we will only merge
242 * two adjacent regions
243 * @throws IOException
244 */
245 void dispatchMergingRegions(
246 final HRegionInfo region_a, final HRegionInfo region_b, final boolean forcible
247 ) throws IOException;
248
249 /**
250 * @return true if master is initialized
251 */
252 boolean isInitialized();
253
254 /**
255 * Create a new namespace
256 * @param descriptor descriptor which describes the new namespace
257 * @throws IOException
258 */
259 public void createNamespace(NamespaceDescriptor descriptor) throws IOException;
260
261 /**
262 * Modify an existing namespace
263 * @param descriptor descriptor which updates the existing namespace
264 * @throws IOException
265 */
266 public void modifyNamespace(NamespaceDescriptor descriptor) throws IOException;
267
268 /**
269 * Delete an existing namespace. Only empty namespaces (no tables) can be removed.
270 * @param name namespace name
271 * @throws IOException
272 */
273 public void deleteNamespace(String name) throws IOException;
274
275 /**
276 * Abort a procedure.
277 * @param procId ID of the procedure
278 * @param mayInterruptIfRunning if the proc completed at least one step, should it be aborted?
279 * @return true if aborted, false if procedure already completed or does not exist
280 * @throws IOException
281 */
282 public boolean abortProcedure(final long procId, final boolean mayInterruptIfRunning)
283 throws IOException;
284
285 /**
286 * List procedures
287 * @return procedure list
288 * @throws IOException
289 */
290 public List<ProcedureInfo> listProcedures() throws IOException;
291
292 /**
293 * Get a namespace descriptor by name
294 * @param name name of namespace descriptor
295 * @return A descriptor
296 * @throws IOException
297 */
298 public NamespaceDescriptor getNamespaceDescriptor(String name) throws IOException;
299
300 /**
301 * List available namespace descriptors
302 * @return A descriptor
303 * @throws IOException
304 */
305 public List<NamespaceDescriptor> listNamespaceDescriptors() throws IOException;
306
307 /**
308 * Get list of table descriptors by namespace
309 * @param name namespace name
310 * @return descriptors
311 * @throws IOException
312 */
313 public List<HTableDescriptor> listTableDescriptorsByNamespace(String name) throws IOException;
314
315 /**
316 * Get list of table names by namespace
317 * @param name namespace name
318 * @return table names
319 * @throws IOException
320 */
321 public List<TableName> listTableNamesByNamespace(String name) throws IOException;
322
323 /**
324 * @param table
325 * @return the timestamp of the last successful major compaction for the passed table,
326 * or 0 if no HFile resulting from a major compaction exists
327 * @throws IOException
328 */
329 public long getLastMajorCompactionTimestamp(TableName table) throws IOException;
330
331 /**
332 * @param regionName
333 * @return the timestamp of the last successful major compaction for the passed region
334 * or 0 if no HFile resulting from a major compaction exists
335 * @throws IOException
336 */
337 public long getLastMajorCompactionTimestampForRegion(byte[] regionName) throws IOException;
338
339 /**
340 * @return load balancer
341 */
342 public LoadBalancer getLoadBalancer();
343
344 public TableStateManager getTableStateManager();
345 }