/**
* @param implementation An {@link HRegionInterface} instance; you'll likely want to pass a mocked
* HRS; can be null.
* @return Mock up a connection that returns a {@link org.apache.hadoop.conf.Configuration} when
* {@link HConnection#getConfiguration()} is called, a 'location' when {@link
* HConnection#getRegionLocation(byte[], byte[], boolean)} is called, and that returns the
* passed {@link HRegionInterface} instance when {@link
* HConnection#getHRegionConnection(String, int)} is called (Be sure call {@link
* HConnectionManager#deleteConnection(org.apache.hadoop.conf.Configuration)} when done with
* this mocked Connection.
* @throws IOException
*/
private HConnection mockConnection(final HRegionInterface implementation) throws IOException {
HConnection connection = HConnectionTestingUtility.getMockedConnection(UTIL.getConfiguration());
Mockito.doNothing().when(connection).close();
// Make it so we return any old location when asked.
final HRegionLocation anyLocation =
new HRegionLocation(HRegionInfo.FIRST_META_REGIONINFO, SN.getHostname(), SN.getPort());
Mockito.when(
connection.getRegionLocation(
(byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean()))
.thenReturn(anyLocation);
Mockito.when(connection.locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any()))
.thenReturn(anyLocation);
if (implementation != null) {
// If a call to getHRegionConnection, return this implementation.
Mockito.when(connection.getHRegionConnection(Mockito.anyString(), Mockito.anyInt()))
.thenReturn(implementation);
}
return connection;
}
/**
* Calls {@link #getMockedConnection(Configuration)} and then mocks a few more of the popular
* {@link HConnection} methods so they do 'normal' operation (see return doc below for list). Be
* sure to shutdown the connection when done by calling {@link
* HConnectionManager#deleteConnection(Configuration, boolean)} else it will stick around; this is
* probably not what you want.
*
* @param implementation An {@link HRegionInterface} instance; you'll likely want to pass a mocked
* HRS; can be null.
* @param conf Configuration to use
* @param implementation An HRegionInterface; can be null but is usually itself a mock.
* @param sn ServerName to include in the region location returned by this <code>implementation
* </code>
* @param hri HRegionInfo to include in the location returned when getRegionLocation is called on
* the mocked connection
* @return Mock up a connection that returns a {@link Configuration} when {@link
* HConnection#getConfiguration()} is called, a 'location' when {@link
* HConnection#getRegionLocation(byte[], byte[], boolean)} is called, and that returns the
* passed {@link HRegionInterface} instance when {@link
* HConnection#getHRegionConnection(String, int)} is called (Be sure call {@link
* HConnectionManager#deleteConnection(org.apache.hadoop.conf.Configuration, boolean)} when
* done with this mocked Connection.
* @throws IOException
*/
public static HConnection getMockedConnectionAndDecorate(
final Configuration conf,
final HRegionInterface implementation,
final ServerName sn,
final HRegionInfo hri)
throws IOException {
HConnection c = HConnectionTestingUtility.getMockedConnection(conf);
Mockito.doNothing().when(c).close();
// Make it so we return a particular location when asked.
final HRegionLocation loc = new HRegionLocation(hri, sn.getHostname(), sn.getPort());
Mockito.when(
c.getRegionLocation(
(byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean()))
.thenReturn(loc);
Mockito.when(c.locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any())).thenReturn(loc);
if (implementation != null) {
// If a call to getHRegionConnection, return this implementation.
Mockito.when(c.getHRegionConnection(Mockito.anyString(), Mockito.anyInt()))
.thenReturn(implementation);
}
return c;
}
/**
* Test that MetaReader will ride over server throwing "Server not running" IOEs.
*
* @see https://issues.apache.org/jira/browse/HBASE-3446
* @throws IOException
* @throws InterruptedException
*/
@Test
public void testRideOverServerNotRunning() throws IOException, InterruptedException {
// Need a zk watcher.
ZooKeeperWatcher zkw =
new ZooKeeperWatcher(
UTIL.getConfiguration(), this.getClass().getSimpleName(), ABORTABLE, true);
// This is a servername we use in a few places below.
ServerName sn = new ServerName("example.com", 1234, System.currentTimeMillis());
HConnection connection = null;
CatalogTracker ct = null;
try {
// Mock an HRegionInterface. Our mock implementation will fail a few
// times when we go to open a scanner.
final HRegionInterface implementation = Mockito.mock(HRegionInterface.class);
// When openScanner called throw IOE 'Server not running' a few times
// before we return a scanner id. Whats WEIRD is that these
// exceptions do not show in the log because they are caught and only
// printed if we FAIL. We eventually succeed after retry so these don't
// show. We will know if they happened or not because we will ask
// mockito at the end of this test to verify that openscanner was indeed
// called the wanted number of times.
final long scannerid = 123L;
Mockito.when(implementation.openScanner((byte[]) Mockito.any(), (Scan) Mockito.any()))
.thenThrow(new IOException("Server not running (1 of 3)"))
.thenThrow(new IOException("Server not running (2 of 3)"))
.thenThrow(new IOException("Server not running (3 of 3)"))
.thenReturn(scannerid);
// Make it so a verifiable answer comes back when next is called. Return
// the verifiable answer and then a null so we stop scanning. Our
// verifiable answer is something that looks like a row in META with
// a server and startcode that is that of the above defined servername.
List<KeyValue> kvs = new ArrayList<KeyValue>();
final byte[] rowToVerify = Bytes.toBytes("rowToVerify");
kvs.add(
new KeyValue(
rowToVerify,
HConstants.CATALOG_FAMILY,
HConstants.REGIONINFO_QUALIFIER,
Writables.getBytes(HRegionInfo.FIRST_META_REGIONINFO)));
kvs.add(
new KeyValue(
rowToVerify,
HConstants.CATALOG_FAMILY,
HConstants.SERVER_QUALIFIER,
Bytes.toBytes(sn.getHostAndPort())));
kvs.add(
new KeyValue(
rowToVerify,
HConstants.CATALOG_FAMILY,
HConstants.STARTCODE_QUALIFIER,
Bytes.toBytes(sn.getStartcode())));
final Result[] result = new Result[] {new Result(kvs)};
Mockito.when(implementation.next(Mockito.anyLong(), Mockito.anyInt()))
.thenReturn(result)
.thenReturn(null);
// Associate a spied-upon HConnection with UTIL.getConfiguration. Need
// to shove this in here first so it gets picked up all over; e.g. by
// HTable.
connection = HConnectionTestingUtility.getSpiedConnection(UTIL.getConfiguration());
// Fix the location lookup so it 'works' though no network. First
// make an 'any location' object.
final HRegionLocation anyLocation =
new HRegionLocation(HRegionInfo.FIRST_META_REGIONINFO, sn.getHostname(), sn.getPort());
// Return the any location object when locateRegion is called in HTable
// constructor and when its called by ServerCallable (it uses getRegionLocation).
// The ugly format below comes of 'Important gotcha on spying real objects!' from
// http://mockito.googlecode.com/svn/branches/1.6/javadoc/org/mockito/Mockito.html
Mockito.doReturn(anyLocation)
.when(connection)
.locateRegion((byte[]) Mockito.any(), (byte[]) Mockito.any());
Mockito.doReturn(anyLocation)
.when(connection)
.getRegionLocation((byte[]) Mockito.any(), (byte[]) Mockito.any(), Mockito.anyBoolean());
// Now shove our HRI implementation into the spied-upon connection.
Mockito.doReturn(implementation)
.when(connection)
.getHRegionConnection(Mockito.anyString(), Mockito.anyInt());
// Now start up the catalogtracker with our doctored Connection.
ct = new CatalogTracker(zkw, null, connection, ABORTABLE, 0);
ct.start();
// Scan meta for user tables and verify we got back expected answer.
NavigableMap<HRegionInfo, Result> hris = MetaReader.getServerUserRegions(ct, sn);
assertTrue(hris.size() == 1);
assertTrue(hris.firstEntry().getKey().equals(HRegionInfo.FIRST_META_REGIONINFO));
assertTrue(Bytes.equals(rowToVerify, hris.firstEntry().getValue().getRow()));
// Finally verify that openscanner was called four times -- three times
// with exception and then on 4th attempt we succeed.
Mockito.verify(implementation, Mockito.times(4))
.openScanner((byte[]) Mockito.any(), (Scan) Mockito.any());
} finally {
if (ct != null) ct.stop();
HConnectionManager.deleteConnection(UTIL.getConfiguration(), true);
zkw.close();
}
}
@Test(expected = RetriesExhaustedException.class)
public void testTimeoutWaitForMeta() throws IOException, InterruptedException {
HConnection connection = HConnectionTestingUtility.getMockedConnection(UTIL.getConfiguration());
final CatalogTracker ct = constructAndStartCatalogTracker(connection);
ct.waitForMeta(100);
}
