View Javadoc

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.File;
22  import java.io.IOException;
23  import java.util.List;
24  
25  import org.apache.commons.cli.CommandLine;
26  import org.apache.commons.cli.GnuParser;
27  import org.apache.commons.cli.Options;
28  import org.apache.commons.cli.ParseException;
29  import org.apache.commons.logging.Log;
30  import org.apache.commons.logging.LogFactory;
31  import org.apache.hadoop.hbase.classification.InterfaceAudience;
32  import org.apache.hadoop.conf.Configuration;
33  import org.apache.hadoop.hbase.CoordinatedStateManager;
34  import org.apache.hadoop.hbase.CoordinatedStateManagerFactory;
35  import org.apache.hadoop.hbase.HConstants;
36  import org.apache.hadoop.hbase.LocalHBaseCluster;
37  import org.apache.hadoop.hbase.MasterNotRunningException;
38  import org.apache.hadoop.hbase.ZNodeClearer;
39  import org.apache.hadoop.hbase.ZooKeeperConnectionException;
40  import org.apache.hadoop.hbase.client.Admin;
41  import org.apache.hadoop.hbase.client.HBaseAdmin;
42  import org.apache.hadoop.hbase.regionserver.HRegionServer;
43  import org.apache.hadoop.hbase.util.JVMClusterUtil;
44  import org.apache.hadoop.hbase.util.ServerCommandLine;
45  import org.apache.hadoop.hbase.zookeeper.MiniZooKeeperCluster;
46  import org.apache.hadoop.hbase.zookeeper.ZKUtil;
47  import org.apache.hadoop.metrics2.lib.DefaultMetricsSystem;
48  import org.apache.zookeeper.KeeperException;
49  
50  @InterfaceAudience.Private
51  public class HMasterCommandLine extends ServerCommandLine {
52    private static final Log LOG = LogFactory.getLog(HMasterCommandLine.class);
53  
54    private static final String USAGE =
55      "Usage: Master [opts] start|stop|clear\n" +
56      " start  Start Master. If local mode, start Master and RegionServer in same JVM\n" +
57      " stop   Start cluster shutdown; Master signals RegionServer shutdown\n" +
58      " clear  Delete the master znode in ZooKeeper after a master crashes\n "+
59      " where [opts] are:\n" +
60      "   --minRegionServers=<servers>   Minimum RegionServers needed to host user tables.\n" +
61      "   --localRegionServers=<servers> " +
62        "RegionServers to start in master process when in standalone mode.\n" +
63      "   --masters=<servers>            Masters to start in this process.\n" +
64      "   --backup                       Master should start in backup mode";
65  
66    private final Class<? extends HMaster> masterClass;
67  
68    public HMasterCommandLine(Class<? extends HMaster> masterClass) {
69      this.masterClass = masterClass;
70    }
71  
72    protected String getUsage() {
73      return USAGE;
74    }
75  
76  
77    public int run(String args[]) throws Exception {
78      Options opt = new Options();
79      opt.addOption("localRegionServers", true,
80        "RegionServers to start in master process when running standalone");
81      opt.addOption("masters", true, "Masters to start in this process");
82      opt.addOption("minRegionServers", true, "Minimum RegionServers needed to host user tables");
83      opt.addOption("backup", false, "Do not try to become HMaster until the primary fails");
84  
85      CommandLine cmd;
86      try {
87        cmd = new GnuParser().parse(opt, args);
88      } catch (ParseException e) {
89        LOG.error("Could not parse: ", e);
90        usage(null);
91        return 1;
92      }
93  
94  
95      if (cmd.hasOption("minRegionServers")) {
96        String val = cmd.getOptionValue("minRegionServers");
97        getConf().setInt("hbase.regions.server.count.min",
98                    Integer.valueOf(val));
99        LOG.debug("minRegionServers set to " + val);
100     }
101 
102     // minRegionServers used to be minServers.  Support it too.
103     if (cmd.hasOption("minServers")) {
104       String val = cmd.getOptionValue("minServers");
105       getConf().setInt("hbase.regions.server.count.min",
106                   Integer.valueOf(val));
107       LOG.debug("minServers set to " + val);
108     }
109 
110     // check if we are the backup master - override the conf if so
111     if (cmd.hasOption("backup")) {
112       getConf().setBoolean(HConstants.MASTER_TYPE_BACKUP, true);
113     }
114 
115     // How many regionservers to startup in this process (we run regionservers in same process as
116     // master when we are in local/standalone mode. Useful testing)
117     if (cmd.hasOption("localRegionServers")) {
118       String val = cmd.getOptionValue("localRegionServers");
119       getConf().setInt("hbase.regionservers", Integer.valueOf(val));
120       LOG.debug("localRegionServers set to " + val);
121     }
122     // How many masters to startup inside this process; useful testing
123     if (cmd.hasOption("masters")) {
124       String val = cmd.getOptionValue("masters");
125       getConf().setInt("hbase.masters", Integer.valueOf(val));
126       LOG.debug("masters set to " + val);
127     }
128 
129     @SuppressWarnings("unchecked")
130     List<String> remainingArgs = cmd.getArgList();
131     if (remainingArgs.size() != 1) {
132       usage(null);
133       return 1;
134     }
135 
136     String command = remainingArgs.get(0);
137 
138     if ("start".equals(command)) {
139       return startMaster();
140     } else if ("stop".equals(command)) {
141       return stopMaster();
142     } else if ("clear".equals(command)) {
143       return (ZNodeClearer.clear(getConf()) ? 0 : 1);
144     } else {
145       usage("Invalid command: " + command);
146       return 1;
147     }
148   }
149 
150   private int startMaster() {
151     Configuration conf = getConf();
152     try {
153       // If 'local', defer to LocalHBaseCluster instance.  Starts master
154       // and regionserver both in the one JVM.
155       if (LocalHBaseCluster.isLocal(conf)) {
156         DefaultMetricsSystem.setMiniClusterMode(true);
157         final MiniZooKeeperCluster zooKeeperCluster = new MiniZooKeeperCluster(conf);
158         File zkDataPath = new File(conf.get(HConstants.ZOOKEEPER_DATA_DIR));
159         int zkClientPort = conf.getInt(HConstants.ZOOKEEPER_CLIENT_PORT, 0);
160         if (zkClientPort == 0) {
161           throw new IOException("No config value for "
162               + HConstants.ZOOKEEPER_CLIENT_PORT);
163         }
164         zooKeeperCluster.setDefaultClientPort(zkClientPort);
165 
166         // login the zookeeper server principal (if using security)
167         ZKUtil.loginServer(conf, "hbase.zookeeper.server.keytab.file",
168           "hbase.zookeeper.server.kerberos.principal", null);
169         int localZKClusterSessionTimeout =
170           conf.getInt(HConstants.ZK_SESSION_TIMEOUT + ".localHBaseCluster", 10*1000);
171         conf.setInt(HConstants.ZK_SESSION_TIMEOUT, localZKClusterSessionTimeout);
172         LOG.info("Starting a zookeeper cluster");
173         int clientPort = zooKeeperCluster.startup(zkDataPath);
174         if (clientPort != zkClientPort) {
175           String errorMsg = "Could not start ZK at requested port of " +
176             zkClientPort + ".  ZK was started at port: " + clientPort +
177             ".  Aborting as clients (e.g. shell) will not be able to find " +
178             "this ZK quorum.";
179           System.err.println(errorMsg);
180           throw new IOException(errorMsg);
181         }
182         conf.set(HConstants.ZOOKEEPER_CLIENT_PORT, Integer.toString(clientPort));
183         // Need to have the zk cluster shutdown when master is shutdown.
184         // Run a subclass that does the zk cluster shutdown on its way out.
185         int mastersCount = conf.getInt("hbase.masters", 1);
186         int regionServersCount = conf.getInt("hbase.regionservers", 1);
187         LOG.info("Starting up instance of localHBaseCluster; master=" + mastersCount +
188           ", regionserversCount=" + regionServersCount);
189         LocalHBaseCluster cluster = new LocalHBaseCluster(conf, mastersCount, regionServersCount,
190           LocalHMaster.class, HRegionServer.class);
191         ((LocalHMaster)cluster.getMaster(0)).setZKCluster(zooKeeperCluster);
192         cluster.startup();
193         waitOnMasterThreads(cluster);
194       } else {
195         logProcessInfo(getConf());
196         CoordinatedStateManager csm =
197           CoordinatedStateManagerFactory.getCoordinatedStateManager(conf);
198         HMaster master = HMaster.constructMaster(masterClass, conf, csm);
199         if (master.isStopped()) {
200           LOG.info("Won't bring the Master up as a shutdown is requested");
201           return 1;
202         }
203         master.start();
204         master.join();
205         if(master.isAborted())
206           throw new RuntimeException("HMaster Aborted");
207       }
208     } catch (Throwable t) {
209       LOG.error("Master exiting", t);
210       return 1;
211     }
212     return 0;
213   }
214 
215   @SuppressWarnings("resource")
216   private int stopMaster() {
217     Admin adm = null;
218     try {
219       Configuration conf = getConf();
220       // Don't try more than once
221       conf.setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 1);
222       adm = new HBaseAdmin(getConf());
223     } catch (MasterNotRunningException e) {
224       LOG.error("Master not running");
225       return 1;
226     } catch (ZooKeeperConnectionException e) {
227       LOG.error("ZooKeeper not available");
228       return 1;
229     } catch (IOException e) {
230       LOG.error("Got IOException: " +e.getMessage(), e);
231       return 1;
232     }
233     try {
234       adm.shutdown();
235     } catch (Throwable t) {
236       LOG.error("Failed to stop master", t);
237       return 1;
238     }
239     return 0;
240   }
241 
242   private void waitOnMasterThreads(LocalHBaseCluster cluster) throws InterruptedException{
243     List<JVMClusterUtil.MasterThread> masters = cluster.getMasters();
244     List<JVMClusterUtil.RegionServerThread> regionservers = cluster.getRegionServers();
245 
246     if (masters != null) {
247       for (JVMClusterUtil.MasterThread t : masters) {
248         t.join();
249         if(t.getMaster().isAborted()) {
250           closeAllRegionServerThreads(regionservers);
251           throw new RuntimeException("HMaster Aborted");
252         }
253       }
254     }
255   }
256 
257   private static void closeAllRegionServerThreads(List<JVMClusterUtil.RegionServerThread> regionservers) {
258     for(JVMClusterUtil.RegionServerThread t : regionservers){
259       t.getRegionServer().stop("HMaster Aborted; Bringing down regions servers");
260     }
261   }
262 
263   /*
264    * Version of master that will shutdown the passed zk cluster on its way out.
265    */
266   public static class LocalHMaster extends HMaster {
267     private MiniZooKeeperCluster zkcluster = null;
268 
269     public LocalHMaster(Configuration conf, CoordinatedStateManager csm)
270     throws IOException, KeeperException, InterruptedException {
271       super(conf, csm);
272     }
273 
274     @Override
275     public void run() {
276       super.run();
277       if (this.zkcluster != null) {
278         try {
279           this.zkcluster.shutdown();
280         } catch (IOException e) {
281           e.printStackTrace();
282         }
283       }
284     }
285 
286     void setZKCluster(final MiniZooKeeperCluster zkcluster) {
287       this.zkcluster = zkcluster;
288     }
289   }
290 }