Source code

Package org.apache.hadoop.hbase.regionserver

Class org.apache.hadoop.hbase.regionserver.InvalidMutationDurabilityException extends org.apache.hadoop.hbase.DoNotRetryIOException implements Serializable

http://git-wip-us.apache.org/repos/asf/hbase-site/blob/fa850293/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.html ---------------------------------------------------------------------- diff --git a/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.html b/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.html new file mode 100644 index 0000000..7f85096 --- /dev/null +++ b/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestInvalidMutationDurabilityException.html @@ -0,0 +1,228 @@ + + + +Source code + + + +

001/**
+002 *
+003 * Licensed to the Apache Software Foundation (ASF) under one
+004 * or more contributor license agreements.  See the NOTICE file
+005 * distributed with this work for additional information
+006 * regarding copyright ownership.  The ASF licenses this file
+007 * to you under the Apache License, Version 2.0 (the
+008 * "License"); you may not use this file except in compliance
+009 * with the License.  You may obtain a copy of the License at
+010 *
+011 *     http://www.apache.org/licenses/LICENSE-2.0
+012 *
+013 * Unless required by applicable law or agreed to in writing, software
+014 * distributed under the License is distributed on an "AS IS" BASIS,
+015 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+016 * See the License for the specific language governing permissions and
+017 * limitations under the License.
+018 */
+019package org.apache.hadoop.hbase.client;
+020
+021import org.apache.hadoop.hbase.HBaseClassTestRule;
+022import org.apache.hadoop.hbase.HBaseTestingUtility;
+023import org.apache.hadoop.hbase.HConstants;
+024import org.apache.hadoop.hbase.TableName;
+025import org.apache.hadoop.hbase.regionserver.InvalidMutationDurabilityException;
+026import org.apache.hadoop.hbase.testclassification.ClientTests;
+027import org.apache.hadoop.hbase.testclassification.MediumTests;
+028import org.apache.hadoop.hbase.util.Bytes;
+029import org.junit.AfterClass;
+030import org.junit.BeforeClass;
+031import org.junit.ClassRule;
+032import org.junit.Test;
+033import org.junit.experimental.categories.Category;
+034
+035@Category({ MediumTests.class, ClientTests.class })
+036public class TestInvalidMutationDurabilityException {
+037
+038  @ClassRule
+039  public static final HBaseClassTestRule CLASS_RULE =
+040      HBaseClassTestRule.forClass(TestInvalidMutationDurabilityException.class);
+041
+042  private static final HBaseTestingUtility UTIL = new HBaseTestingUtility();
+043
+044  private static TableName TABLE_NOT_REPLICATE = TableName.valueOf("TableNotReplicate");
+045
+046  private static TableName TABLE_NEED_REPLICATE = TableName.valueOf("TableNeedReplicate");
+047
+048  private static byte[] CF = Bytes.toBytes("cf");
+049
+050  private static byte[] CQ = Bytes.toBytes("cq");
+051
+052  private static Table tableNotReplicate;
+053
+054  private static Table tableNeedReplicate;
+055
+056  @BeforeClass
+057  public static void setUp() throws Exception {
+058    UTIL.startMiniCluster();
+059    UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_NOT_REPLICATE)
+060        .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build());
+061    UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_NEED_REPLICATE)
+062        .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF)
+063            .setScope(HConstants.REPLICATION_SCOPE_GLOBAL).build()).build());
+064    tableNotReplicate = UTIL.getConnection().getTable(TABLE_NOT_REPLICATE);
+065    tableNeedReplicate = UTIL.getConnection().getTable(TABLE_NEED_REPLICATE);
+066  }
+067
+068  @AfterClass
+069  public static void tearDown() throws Exception {
+070    UTIL.getAdmin().disableTable(TABLE_NOT_REPLICATE);
+071    UTIL.getAdmin().disableTable(TABLE_NEED_REPLICATE);
+072    UTIL.getAdmin().deleteTable(TABLE_NOT_REPLICATE);
+073    UTIL.getAdmin().deleteTable(TABLE_NEED_REPLICATE);
+074    UTIL.shutdownMiniCluster();
+075  }
+076
+077  private Put newPutWithSkipWAL() {
+078    Put put = new Put(Bytes.toBytes("row"));
+079    put.addColumn(CF, CQ, Bytes.toBytes("value"));
+080    put.setDurability(Durability.SKIP_WAL);
+081    return put;
+082  }
+083
+084  @Test
+085  public void testPutToTableNotReplicate() throws Exception {
+086    tableNotReplicate.put(newPutWithSkipWAL());
+087  }
+088
+089  @Test(expected = InvalidMutationDurabilityException.class)
+090  public void testPutToTableNeedReplicate() throws Exception {
+091    tableNeedReplicate.put(newPutWithSkipWAL());
+092  }
+093
+094  private Delete newDeleteWithSkipWAL() {
+095    Delete delete = new Delete(Bytes.toBytes("row"));
+096    delete.addColumn(CF, CQ);
+097    delete.setDurability(Durability.SKIP_WAL);
+098    return delete;
+099  }
+100
+101  @Test
+102  public void testDeleteToTableNotReplicate() throws Exception {
+103    tableNotReplicate.delete(newDeleteWithSkipWAL());
+104  }
+105
+106  @Test(expected = InvalidMutationDurabilityException.class)
+107  public void testDeleteToTableNeedReplicate() throws Exception {
+108    tableNeedReplicate.delete(newDeleteWithSkipWAL());
+109  }
+110
+111  private Append newAppendWithSkipWAL() {
+112    Append append = new Append(Bytes.toBytes("row"));
+113    append.addColumn(CF, CQ, Bytes.toBytes("value"));
+114    append.setDurability(Durability.SKIP_WAL);
+115    return append;
+116  }
+117
+118  @Test
+119  public void testAppendToTableNotReplicate() throws Exception {
+120    tableNotReplicate.append(newAppendWithSkipWAL());
+121  }
+122
+123  @Test(expected = InvalidMutationDurabilityException.class)
+124  public void testAppendToTableNeedReplicate() throws Exception {
+125    tableNeedReplicate.append(newAppendWithSkipWAL());
+126  }
+127
+128  private Increment newIncrementWithSkipWAL() {
+129    Increment increment = new Increment(Bytes.toBytes("row"));
+130    increment.addColumn(CF, CQ, 1);
+131    increment.setDurability(Durability.SKIP_WAL);
+132    return increment;
+133  }
+134
+135  @Test
+136  public void testIncrementToTableNotReplicate() throws Exception {
+137    tableNotReplicate.increment(newIncrementWithSkipWAL());
+138  }
+139
+140  @Test(expected = InvalidMutationDurabilityException.class)
+141  public void testIncrementToTableNeedReplicate() throws Exception {
+142    tableNeedReplicate.increment(newIncrementWithSkipWAL());
+143  }
+144
+145  @Test
+146  public void testCheckWithMutateToTableNotReplicate() throws Exception {
+147    tableNotReplicate.checkAndMutate(Bytes.toBytes("row"), CF).qualifier(CQ).ifNotExists()
+148        .thenPut(newPutWithSkipWAL());
+149  }
+150
+151  @Test(expected = InvalidMutationDurabilityException.class)
+152  public void testCheckWithMutateToTableNeedReplicate() throws Exception {
+153    tableNeedReplicate.checkAndMutate(Bytes.toBytes("row"), CF).qualifier(CQ).ifNotExists()
+154        .thenPut(newPutWithSkipWAL());
+155  }
+156}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+ + http://git-wip-us.apache.org/repos/asf/hbase-site/blob/fa850293/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestTableOperationException.ThrowDoNotRetryIOExceptionCoprocessor.html ---------------------------------------------------------------------- diff --git a/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestTableOperationException.ThrowDoNotRetryIOExceptionCoprocessor.html b/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestTableOperationException.ThrowDoNotRetryIOExceptionCoprocessor.html new file mode 100644 index 0000000..0f6bfca --- /dev/null +++ b/testdevapidocs/src-html/org/apache/hadoop/hbase/client/TestTableOperationException.ThrowDoNotRetryIOExceptionCoprocessor.html @@ -0,0 +1,294 @@ + + + +Source code + + + +

001/**
+002 * Licensed to the Apache Software Foundation (ASF) under one
+003 * or more contributor license agreements.  See the NOTICE file
+004 * distributed with this work for additional information
+005 * regarding copyright ownership.  The ASF licenses this file
+006 * to you under the Apache License, Version 2.0 (the
+007 * "License"); you may not use this file except in compliance
+008 * with the License.  You may obtain a copy of the License at
+009 *
+010 *     http://www.apache.org/licenses/LICENSE-2.0
+011 *
+012 * Unless required by applicable law or agreed to in writing, software
+013 * distributed under the License is distributed on an "AS IS" BASIS,
+014 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+015 * See the License for the specific language governing permissions and
+016 * limitations under the License.
+017 */
+018package org.apache.hadoop.hbase.client;
+019
+020import java.io.IOException;
+021import java.util.List;
+022import java.util.Optional;
+023
+024import org.apache.hadoop.hbase.Cell;
+025import org.apache.hadoop.hbase.DoNotRetryIOException;
+026import org.apache.hadoop.hbase.HBaseClassTestRule;
+027import org.apache.hadoop.hbase.HBaseTestingUtility;
+028import org.apache.hadoop.hbase.HConstants;
+029import org.apache.hadoop.hbase.TableName;
+030import org.apache.hadoop.hbase.coprocessor.ObserverContext;
+031import org.apache.hadoop.hbase.coprocessor.RegionCoprocessor;
+032import org.apache.hadoop.hbase.coprocessor.RegionCoprocessorEnvironment;
+033import org.apache.hadoop.hbase.coprocessor.RegionObserver;
+034import org.apache.hadoop.hbase.testclassification.ClientTests;
+035import org.apache.hadoop.hbase.testclassification.MediumTests;
+036import org.apache.hadoop.hbase.util.Bytes;
+037import org.apache.hadoop.hbase.wal.WALEdit;
+038import org.junit.AfterClass;
+039import org.junit.BeforeClass;
+040import org.junit.ClassRule;
+041import org.junit.Test;
+042import org.junit.experimental.categories.Category;
+043
+044@Category({MediumTests.class, ClientTests.class})
+045public class TestTableOperationException {
+046
+047  @ClassRule
+048  public static final HBaseClassTestRule CLASS_RULE =
+049      HBaseClassTestRule.forClass(TestTableOperationException.class);
+050
+051  private static final HBaseTestingUtility UTIL = new HBaseTestingUtility();
+052
+053  private static TableName TABLE_DONOT_RETRY = TableName.valueOf("TableDoNotRetry");
+054
+055  private static TableName TABLE_RETRY = TableName.valueOf("TableRetry");
+056
+057  private static Table tableDoNotRetry;
+058
+059  private static Table tableRetry;
+060
+061  private static byte[] CF = Bytes.toBytes("cf");
+062
+063  private static byte[] CQ = Bytes.toBytes("cq");
+064
+065  @BeforeClass
+066  public static void setUp() throws Exception {
+067    UTIL.getConfiguration().setInt(HConstants.HBASE_CLIENT_RETRIES_NUMBER, 2);
+068    UTIL.startMiniCluster();
+069    UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_DONOT_RETRY)
+070        .setCoprocessor(ThrowDoNotRetryIOExceptionCoprocessor.class.getName())
+071        .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build());
+072    UTIL.getAdmin().createTable(TableDescriptorBuilder.newBuilder(TABLE_RETRY)
+073        .setCoprocessor(ThrowIOExceptionCoprocessor.class.getName())
+074        .setColumnFamily(ColumnFamilyDescriptorBuilder.newBuilder(CF).build()).build());
+075    tableDoNotRetry = UTIL.getConnection().getTable(TABLE_DONOT_RETRY);
+076    tableRetry = UTIL.getConnection().getTable(TABLE_RETRY);
+077  }
+078
+079  @AfterClass
+080  public static void tearDown() throws Exception {
+081    UTIL.getAdmin().disableTable(TABLE_DONOT_RETRY);
+082    UTIL.getAdmin().disableTable(TABLE_RETRY);
+083    UTIL.getAdmin().deleteTable(TABLE_DONOT_RETRY);
+084    UTIL.getAdmin().deleteTable(TABLE_RETRY);
+085    UTIL.shutdownMiniCluster();
+086  }
+087
+088  @Test(expected = DoNotRetryIOException.class)
+089  public void testGetWithDoNotRetryIOException() throws Exception {
+090    tableDoNotRetry.get(new Get(Bytes.toBytes("row")).addColumn(CF, CQ));
+091  }
+092
+093  @Test(expected = DoNotRetryIOException.class)
+094  public void testPutWithDoNotRetryIOException() throws Exception {
+095    tableDoNotRetry.put(new Put(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value")));
+096  }
+097
+098  @Test(expected = DoNotRetryIOException.class)
+099  public void testDeleteWithDoNotRetryIOException() throws Exception {
+100    tableDoNotRetry.delete(new Delete(Bytes.toBytes("row")).addColumn(CF, CQ));
+101  }
+102
+103  @Test(expected = DoNotRetryIOException.class)
+104  public void testAppendWithDoNotRetryIOException() throws Exception {
+105    tableDoNotRetry
+106        .append(new Append(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value")));
+107  }
+108
+109  @Test(expected = DoNotRetryIOException.class)
+110  public void testIncrementWithDoNotRetryIOException() throws Exception {
+111    tableDoNotRetry.increment(new Increment(Bytes.toBytes("row")).addColumn(CF, CQ, 1));
+112  }
+113
+114  @Test(expected = RetriesExhaustedException.class)
+115  public void testGetWithIOException() throws Exception {
+116    tableRetry.get(new Get(Bytes.toBytes("row")).addColumn(CF, CQ));
+117  }
+118
+119  @Test(expected = RetriesExhaustedException.class)
+120  public void testPutWithIOException() throws Exception {
+121    tableRetry.put(new Put(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value")));
+122  }
+123
+124  @Test(expected = RetriesExhaustedException.class)
+125  public void testDeleteWithIOException() throws Exception {
+126    tableRetry.delete(new Delete(Bytes.toBytes("row")).addColumn(CF, CQ));
+127  }
+128
+129  @Test(expected = RetriesExhaustedException.class)
+130  public void testAppendWithIOException() throws Exception {
+131    tableRetry.append(new Append(Bytes.toBytes("row")).addColumn(CF, CQ, Bytes.toBytes("value")));
+132  }
+133
+134  @Test(expected = RetriesExhaustedException.class)
+135  public void testIncrementWithIOException() throws Exception {
+136    tableRetry.increment(new Increment(Bytes.toBytes("row")).addColumn(CF, CQ, 1));
+137  }
+138
+139  public static class ThrowDoNotRetryIOExceptionCoprocessor
+140      implements RegionCoprocessor, RegionObserver {
+141
+142    public ThrowDoNotRetryIOExceptionCoprocessor() {
+143    }
+144
+145    @Override
+146    public Optional<RegionObserver> getRegionObserver() {
+147      return Optional.of(this);
+148    }
+149
+150    @Override
+151    public void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> e, final Get get,
+152        final List<Cell> results) throws IOException {
+153      throw new DoNotRetryIOException("Call failed and don't retry");
+154    }
+155
+156    @Override
+157    public void prePut(final ObserverContext<RegionCoprocessorEnvironment> e, final Put put,
+158        final WALEdit edit, final Durability durability) throws IOException {
+159      throw new DoNotRetryIOException("Call failed and don't retry");
+160    }
+161
+162    @Override
+163    public void preDelete(final ObserverContext<RegionCoprocessorEnvironment> e,
+164        final Delete delete, final WALEdit edit, final Durability durability) throws IOException {
+165      throw new DoNotRetryIOException("Call failed and don't retry");
+166    }
+167
+168    @Override
+169    public Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> e,
+170        final Increment increment) throws IOException {
+171      throw new DoNotRetryIOException("Call failed and don't retry");
+172    }
+173
+174    @Override
+175    public Result preAppend(final ObserverContext<RegionCoprocessorEnvironment> e,
+176        final Append append) throws IOException {
+177      throw new DoNotRetryIOException("Call failed and don't retry");
+178    }
+179  }
+180
+181  public static class ThrowIOExceptionCoprocessor
+182      implements RegionCoprocessor, RegionObserver {
+183
+184    public ThrowIOExceptionCoprocessor() {
+185    }
+186
+187    @Override
+188    public Optional<RegionObserver> getRegionObserver() {
+189      return Optional.of(this);
+190    }
+191
+192    @Override
+193    public void preGetOp(final ObserverContext<RegionCoprocessorEnvironment> e, final Get get,
+194        final List<Cell> results) throws IOException {
+195      throw new IOException("Call failed and retry");
+196    }
+197
+198    @Override
+199    public void prePut(final ObserverContext<RegionCoprocessorEnvironment> e, final Put put,
+200        final WALEdit edit, final Durability durability) throws IOException {
+201      throw new IOException("Call failed and retry");
+202    }
+203
+204    @Override
+205    public void preDelete(final ObserverContext<RegionCoprocessorEnvironment> e,
+206        final Delete delete, final WALEdit edit, final Durability durability) throws IOException {
+207      throw new IOException("Call failed and retry");
+208    }
+209
+210    @Override
+211    public Result preIncrement(final ObserverContext<RegionCoprocessorEnvironment> e,
+212        final Increment increment) throws IOException {
+213      throw new IOException("Call failed and retry");
+214    }
+215
+216    @Override
+217    public Result preAppend(final ObserverContext<RegionCoprocessorEnvironment> e,
+218        final Append append) throws IOException {
+219      throw new IOException("Call failed and retry");
+220    }
+221  }
+222}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

+ +

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegion

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegion

Methods inherited from class org.apache.hadoop.hbase.regionserver.HRegion

Package org.apache.hadoop.hbase.regionserver

Class org.apache.hadoop.hbase.regionserver.InvalidMutationDurabilityException extends org.apache.hadoop.hbase.DoNotRetryIOException implements Serializable