[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2015-01-22 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14288762#comment-14288762
 ] 

Hudson commented on HBASE-5162:
---

SUCCESS: Integrated in HBase-1.0 #676 (See 
[https://builds.apache.org/job/HBase-1.0/676/])
HBASE-12730 Backport HBASE-5162 (Basic client pushback mechanism) to branch-1 
(apurtell: rev 06eef6dafb51eaeaea9b0566252bcab15be5729d)
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClusterConnection.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ServerStatisticTracker.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/MultiAction.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/Result.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ExponentialClientBackoffPolicy.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/WALEditsReplaySink.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestClientExponentialBackoff.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ServerStatistics.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncProcess.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/HConnectionTestingUtility.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestDelayingRunner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ResultStatsUtil.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java
* hbase-protocol/src/main/protobuf/Client.proto
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionManager.java
* hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/protobuf/ResponseConverter.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/DelayingRunner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionAdapter.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicyFactory.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/ipc/RegionCoprocessorRpcChannel.java
* 
hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/ClientProtos.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2015-01-22 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14288832#comment-14288832
 ] 

Hudson commented on HBASE-5162:
---

SUCCESS: Integrated in HBase-1.1 #99 (See 
[https://builds.apache.org/job/HBase-1.1/99/])
HBASE-12730 Backport HBASE-5162 (Basic client pushback mechanism) to branch-1 
(apurtell: rev 04a003d6a2b628bc551a55ae556c1b44485e3022)
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestDelayingRunner.java
* hbase-protocol/src/main/protobuf/Client.proto
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/DelayingRunner.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/MultiAction.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/ipc/RegionCoprocessorRpcChannel.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/HConnectionTestingUtility.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/protobuf/ResponseConverter.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionManager.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java
* hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicyFactory.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestClientExponentialBackoff.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncProcess.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/Result.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ServerStatisticTracker.java
* hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ResultStatsUtil.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClusterConnection.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ExponentialClientBackoffPolicy.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/WALEditsReplaySink.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ServerStatistics.java
* 
hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/ClientProtos.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionAdapter.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2015-01-19 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14283415#comment-14283415
 ] 

Hudson commented on HBASE-5162:
---

SUCCESS: Integrated in HBase-0.98 #805 (See 
[https://builds.apache.org/job/HBase-0.98/805/])
HBASE-12729 Backport HBASE-5162 (Basic client pushback mechanism) to 0.98 
(apurtell: rev 85e7270b6f8cfb593c1cba137241f2aad986a3e1)
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTableMultiplexer.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicyFactory.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/MultiAction.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestClientExponentialBackoff.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ExponentialClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/protobuf/ResponseConverter.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncProcess.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java
* 
hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/ClientProtos.java
* hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/DelayingRunner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCaller.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClientScanner.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/WALEditsReplaySink.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/Result.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicy.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestDelayingRunner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatisticsHConnection.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ServerStatistics.java
* hbase-protocol/src/main/protobuf/Client.proto
* hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ResultStatsUtil.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClientSmallScanner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ServerStatisticTracker.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2015-01-19 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14283549#comment-14283549
 ] 

Hudson commented on HBASE-5162:
---

SUCCESS: Integrated in HBase-0.98-on-Hadoop-1.1 #768 (See 
[https://builds.apache.org/job/HBase-0.98-on-Hadoop-1.1/768/])
HBASE-12729 Backport HBASE-5162 (Basic client pushback mechanism) to 0.98 
(apurtell: rev 85e7270b6f8cfb593c1cba137241f2aad986a3e1)
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ExponentialClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ServerStatistics.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTableMultiplexer.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClientScanner.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncProcess.java
* hbase-protocol/src/main/protobuf/Client.proto
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatisticsHConnection.java
* hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java
* 
hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/ClientProtos.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ServerStatisticTracker.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/Result.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/DelayingRunner.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicy.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/MultiAction.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestDelayingRunner.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClientSmallScanner.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HBaseAdmin.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/WALEditsReplaySink.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java
* hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicyFactory.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/protobuf/ResponseConverter.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ResultStatsUtil.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestClientExponentialBackoff.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCaller.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2015-01-12 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14274201#comment-14274201
 ] 

Hudson commented on HBASE-5162:
---

FAILURE: Integrated in HBase-TRUNK #6012 (See 
[https://builds.apache.org/job/HBase-TRUNK/6012/])
HBASE-12838 After HBASE-5162 RSRpcServices accidentally applies mutations twice 
(apurtell: rev e52d8f85c48adc772dfe99e1f5cebb814e89c16c)
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249618#comment-14249618
 ] 

Hudson commented on HBASE-5162:
---

FAILURE: Integrated in HBase-TRUNK #5937 (See 
[https://builds.apache.org/job/HBase-TRUNK/5937/])
Revert HBASE-5162 Basic client pushback mechanism (Jesse Yates); ADDENDUM 
(apurtell: rev 6a042c381a04ccd4b82bc51720af7a043e15)
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* hbase-client/pom.xml
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
Amend HBASE-5162 Basic client pushback mechanism (Jesse Yates) (apurtell: rev 
99a11390b4758c211af04af2ca0696ac6e3e0aeb)
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250012#comment-14250012
 ] 

Andrew Purtell commented on HBASE-5162:
---

We need to determine why the test is failing in the Jenkins environment or 
revert. 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread stack (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250308#comment-14250308
 ] 

stack commented on HBASE-5162:
--

Arg. Sorry about that [~apurtell] You seem to be doing a bunch of cleanup after 
me lately.  Let me be better

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Dima Spivak (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250381#comment-14250381
 ] 

Dima Spivak commented on HBASE-5162:


Can someone explain to me where this magic number of 15% comes from? (And then 
where your magic number of 11% comes from, [~tedyu]? :) ) I might well just be 
dense here, but I'm not following what part of the setup of the test dictates a 
memstore load to be expected.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Ted Yu (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250425#comment-14250425
 ] 

Ted Yu commented on HBASE-5162:
---

The test writes some data to client-pushback table and gets memstore load 
through StatisticsTracker.
The load varies: 11 was the reading shown in build #5937.

Jesse would be able to give us more detail.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250479#comment-14250479
 ] 

Jesse Yates commented on HBASE-5162:


thanks all for helping out!

[~dimaspivak] the number is just what the memstore is currently at, load wise, 
which is basically the current number of bytes/number of bytes after which it 
flushes. A put is a certain number of bytes, so it should put a certain amount 
of load on the memstore.

I think what is happening in Jenkins is something is hanging, so the memstore 
is flushing before we expect. I think we can go ahead with Ted's patch, for the 
meantime. An alternative would be to force-flush the table before doing the 
write and then get the load - nothing else should be influencing it.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Ted Yu (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250488#comment-14250488
 ] 

Ted Yu commented on HBASE-5162:
---

Planning to commit the addendum soon - this JIRA is in 1.0 whose RC is coming 
out today.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250490#comment-14250490
 ] 

Jesse Yates commented on HBASE-5162:


This jira isn't actually going into 1.0 - couldn't get [~enis]'s attention to 
ok it going in. I'll move it out to 1.1 for now. Feel free to commit to master 
Ted.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0, 1.1.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Dima Spivak (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250495#comment-14250495
 ] 

Dima Spivak commented on HBASE-5162:


I really don't think changing one arbitrary to another arbitrary number is the 
way to go here; the test will start failing in the future if we ever tweak the 
memstore and that number changes. I think Jesse's alternative solution, setting 
up the memstore in a known state during/before the test is the most reasonable 
thing to do.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0, 1.1.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Ted Yu (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250499#comment-14250499
 ] 

Ted Yu commented on HBASE-5162:
---

Integrated to master branch.

It is not clear when 1.1.0 release comes out. Should this JIRA be resolved and 
a new JIRA opened for backporting to branch-1 ?

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0, 1.1.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250502#comment-14250502
 ] 

Jesse Yates commented on HBASE-5162:


We could. Was hoping to get the 1.0 backport in sooner rather than later, but 
either way works for me

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0, 1.1.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Sean Busbey (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250504#comment-14250504
 ] 

Sean Busbey commented on HBASE-5162:


please make a backport ticket. that's what we've done for other things that 
didn't make the 1.0 cut off.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0, 1.1.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250597#comment-14250597
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:green}+1 overall{color}.  Here are the results of testing the latest 
attachment 
  http://issues.apache.org/jira/secure/attachment/12687800/5162-addendum2.txt
  against master branch at commit 422df8a3f430e1e41f971a644eec298f23decaf8.
  ATTACHMENT ID: 12687800

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 3 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:green}+1 checkstyle{color}.  The applied patch does not increase the 
total number of checkstyle errors

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:green}+1 lineLengths{color}.  The patch does not introduce lines 
longer than 100

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

{color:green}+1 core tests{color}.  The patch passed unit tests in .

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//artifact/patchprocess/checkstyle-aggregate.html

  Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12114//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250640#comment-14250640
 ] 

Andrew Purtell commented on HBASE-5162:
---

[~jesse_yates], what do you think about filing another issue for follow on work 
for the test... We could force flush as suggested above to set things at a 
known state. Or we could maybe mock something. 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250645#comment-14250645
 ] 

Jesse Yates commented on HBASE-5162:


[~apurtell] filed and patch posted: HBASE-12703

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250646#comment-14250646
 ] 

Andrew Purtell commented on HBASE-5162:
---

Ok, oops. Thanks.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-17 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14250683#comment-14250683
 ] 

Hudson commented on HBASE-5162:
---

SUCCESS: Integrated in HBase-TRUNK #5939 (See 
[https://builds.apache.org/job/HBase-TRUNK/5939/])
HBASE-5162 Addendum to stabilize TestClientPushback (tedyu: rev 
6aa8b3727c75bf8578599ec35afcaad245f13e30)
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 2.0.0

 Attachments: 5162-addendum2.txt, hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14248738#comment-14248738
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12687543/hbase-5162-trunk-v12-committed.patch
  against master branch at commit a411227b0ebf78b4ee8ae7179e162b54734e77de.
  ATTACHMENT ID: 12687543

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 19 new 
or modified tests.

{color:red}-1 patch{color}.  The patch command could not apply the patch.

Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12100//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v10.patch, hbase-5162-trunk-v11.patch, 
 hbase-5162-trunk-v12-committed.patch, hbase-5162-trunk-v2.patch, 
 hbase-5162-trunk-v3.patch, hbase-5162-trunk-v4.patch, 
 hbase-5162-trunk-v5.patch, hbase-5162-trunk-v6.patch, 
 hbase-5162-trunk-v7.patch, hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14248780#comment-14248780
 ] 

Andrew Purtell commented on HBASE-5162:
---

I have a feeling [~enis] won't take this at this late time for 1.0. What if we 
open a branch (soon) for 1.1. 

I think we can look at this for 0.98 if we don't break non-private interfaces 
and we can get it back into 0.98 from master via any 1.x. 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14248946#comment-14248946
 ] 

Hudson commented on HBASE-5162:
---

FAILURE: Integrated in HBase-TRUNK #5930 (See 
[https://builds.apache.org/job/HBase-TRUNK/5930/])
HBASE-5162 Basic client pushback mechanism (jyates: rev 
a411227b0ebf78b4ee8ae7179e162b54734e77de)
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestClientExponentialBackoff.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/DelayingRunner.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/wal/WALEditsReplaySink.java
* hbase-protocol/src/main/protobuf/Client.proto
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionManager.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/MultiAction.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ExponentialClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/protobuf/ResponseConverter.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/HConnectionTestingUtility.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCaller.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/mapreduce/LoadIncrementalHFiles.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicyFactory.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/Result.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ClientBackoffPolicy.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerImpl.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ServerStatisticTracker.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ClusterConnection.java
* hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* 
hbase-protocol/src/main/java/org/apache/hadoop/hbase/protobuf/generated/ClientProtos.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/replication/regionserver/TestRegionReplicaReplicationEndpoint.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/ResultStatsUtil.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/HTable.java
* hbase-common/src/main/java/org/apache/hadoop/hbase/HConstants.java
* 
hbase-server/src/main/java/org/apache/hadoop/hbase/regionserver/RSRpcServices.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestReplicasClient.java
* hbase-client/src/main/java/org/apache/hadoop/hbase/client/AsyncProcess.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/ConnectionAdapter.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/backoff/ServerStatistics.java
* 
hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/ipc/RegionCoprocessorRpcChannel.java


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14248961#comment-14248961
 ] 

Jesse Yates commented on HBASE-5162:


Hmmm, well that's an issue. Looking into the NPE now.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14248968#comment-14248968
 ] 

Andrew Purtell commented on HBASE-5162:
---

Thanks. If it's a minor fix please commit an addendum. If it's more involved, 
we can revert and commit again later. 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Nick Dimiduk (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249066#comment-14249066
 ] 

Nick Dimiduk commented on HBASE-5162:
-

bq. What if we open a branch (soon) for 1.1.

Why wait for 1.1, any reason this couldn't go into 1.0.1? I mean, if it's okay 
for 0.98.x, why not 1.0.x?

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249079#comment-14249079
 ] 

Andrew Purtell commented on HBASE-5162:
---

Either option sounds good IMHO :-)

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249254#comment-14249254
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:green}+1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12687610/hbase-5162-trunk-addendum.patch
  against master branch at commit 9e7f7211b95ef4e9c64f5e54411c7c9fa7eeb235.
  ATTACHMENT ID: 12687610

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 3 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:green}+1 checkstyle{color}.  The applied patch does not increase the 
total number of checkstyle errors

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:green}+1 lineLengths{color}.  The patch does not introduce lines 
longer than 100

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

{color:green}+1 core tests{color}.  The patch passed unit tests in .

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//artifact/patchprocess/checkstyle-aggregate.html

  Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12101//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Ted Yu (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249258#comment-14249258
 ] 

Ted Yu commented on HBASE-5162:
---

+1

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread stack (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249462#comment-14249462
 ] 

stack commented on HBASE-5162:
--

The test this patch adds has been failing.  You lot on it (i'm sure you are!)

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249468#comment-14249468
 ] 

Andrew Purtell commented on HBASE-5162:
---

Let's commit the addendum

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249470#comment-14249470
 ] 

Jesse Yates commented on HBASE-5162:


Was just waiting on a +1 from someone else. Im away from my computer till late 
tonight, but can do it tomorrow am, unless someone wants to grab it first

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread stack (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249474#comment-14249474
 ] 

stack commented on HBASE-5162:
--

I can do it. No worries [~jesse_yates]

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread stack (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249477#comment-14249477
 ] 

stack commented on HBASE-5162:
--

[~jesse_yates] Done sir.  BTW, thanks for working on this oldie.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Lars Hofhansl (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249516#comment-14249516
 ] 

Lars Hofhansl commented on HBASE-5162:
--

Looks like this break the compile now...?
{noformat}
[ERROR] Failed to execute goal 
org.apache.maven.plugins:maven-compiler-plugin:3.2:compile (default-compile) on 
project hbase-client: Compilation failure: Compilation failure:
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[44,32]
 package org.apache.hadoop.mapred does not exist
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[45,35]
 package org.apache.hadoop.mapreduce does not exist
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[191,67]
 cannot find symbol
[ERROR] symbol:   class Job
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[212,18]
 cannot find symbol
[ERROR] symbol:   class Job
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[248,46]
 cannot find symbol
[ERROR] symbol:   class JobConf
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[269,69]
 cannot find symbol
[ERROR] symbol:   class JobConf
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[305,66]
 cannot find symbol
[ERROR] symbol:   class JobConf
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
[ERROR] 
/home/lars/dev/hbase-master/hbase-client/src/main/java/org/apache/hadoop/hbase/security/token/TokenUtil.java:[325,71]
 cannot find symbol
[ERROR] symbol:   class Job
[ERROR] location: class org.apache.hadoop.hbase.security.token.TokenUtil
{noformat}


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Hudson (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249526#comment-14249526
 ] 

Hudson commented on HBASE-5162:
---

FAILURE: Integrated in HBase-TRUNK #5936 (See 
[https://builds.apache.org/job/HBase-TRUNK/5936/])
HBASE-5162 Basic client pushback mechanism (Jesse Yates); ADDENDUM (stack: rev 
f7154e1ac9e6c0bd2dd3c39078a52d49d3485504)
* 
hbase-server/src/test/java/org/apache/hadoop/hbase/client/TestClientPushback.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/StatsTrackingRpcRetryingCaller.java
* 
hbase-client/src/main/java/org/apache/hadoop/hbase/client/RpcRetryingCallerFactory.java
* hbase-client/pom.xml


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249531#comment-14249531
 ] 

Andrew Purtell commented on HBASE-5162:
---

The precommit with addendum passed here so what was committed ? 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249538#comment-14249538
 ] 

Andrew Purtell commented on HBASE-5162:
---

POM changes were committed that were not part of the addendum patch. I will fix 
that now.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Dima Spivak (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249541#comment-14249541
 ] 

Dima Spivak commented on HBASE-5162:


Well done, Andy. With your latest push, TestClientPushback passes for me.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-16 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14249540#comment-14249540
 ] 

Andrew Purtell commented on HBASE-5162:
---

I reverted the previous addendum as 6a042c3 and reapplied 
hbase-5162-trunk-addendum.patch as 99a1139. The build is clean here and 
TestClientPushback is passing (5 out of 5 trials).

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-branch-1-v0.patch, 
 hbase-5162-trunk-addendum.patch, hbase-5162-trunk-v0.patch, 
 hbase-5162-trunk-v1.patch, hbase-5162-trunk-v10.patch, 
 hbase-5162-trunk-v11.patch, hbase-5162-trunk-v12-committed.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-15 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14246856#comment-14246856
 ] 

Jesse Yates commented on HBASE-5162:


Think I'm just going to commit this then(and fix the the checkstyle on commit), 
unless there are any objections.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v10.patch, hbase-5162-trunk-v11.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-12 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14244753#comment-14244753
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12686931/hbase-5162-trunk-v10.patch
  against master branch at commit 3275b964c1c1fbb20ffe646b37317496b265660b.
  ATTACHMENT ID: 12686931

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 19 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:green}+1 checkstyle{color}.  The applied patch does not increase the 
total number of checkstyle errors

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:green}+1 lineLengths{color}.  The patch does not introduce lines 
longer than 100

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

 {color:red}-1 core tests{color}.  The patch failed these unit tests:
   org.apache.hadoop.hbase.TestInterfaceAudienceAnnotations

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//artifact/patchprocess/checkstyle-aggregate.html

  Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12058//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v10.patch, hbase-5162-trunk-v2.patch, 
 hbase-5162-trunk-v3.patch, hbase-5162-trunk-v4.patch, 
 hbase-5162-trunk-v5.patch, hbase-5162-trunk-v6.patch, 
 hbase-5162-trunk-v7.patch, hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-12 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14244805#comment-14244805
 ] 

Jesse Yates commented on HBASE-5162:


I'm just running it through the test suite locally now to make sure I didn't do 
any more silly stuff.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v10.patch, hbase-5162-trunk-v2.patch, 
 hbase-5162-trunk-v3.patch, hbase-5162-trunk-v4.patch, 
 hbase-5162-trunk-v5.patch, hbase-5162-trunk-v6.patch, 
 hbase-5162-trunk-v7.patch, hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-12 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14245006#comment-14245006
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12686957/hbase-5162-trunk-v11.patch
  against master branch at commit a0e473730e2cd819e7442dbd2b332d7833755ba2.
  ATTACHMENT ID: 12686957

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 19 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:red}-1 checkstyle{color}.  The applied patch generated 
2090 checkstyle errors (more than the master's current 2089 errors).

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:green}+1 lineLengths{color}.  The patch does not introduce lines 
longer than 100

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

{color:green}+1 core tests{color}.  The patch passed unit tests in .

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//artifact/patchprocess/checkstyle-aggregate.html

Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/12059//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0, 2.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v10.patch, hbase-5162-trunk-v11.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-09 Thread Andrew Purtell (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14240149#comment-14240149
 ] 

Andrew Purtell commented on HBASE-5162:
---

Would you like me to clean up this patch [~jesse_yates]? I don't have more 
review comments, we should get a good QA run and consider commit.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-12-09 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14240292#comment-14240292
 ] 

Jesse Yates commented on HBASE-5162:


Got a bit distracted. I'll have something up tonight or early tomorrow.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, 
 hbase-5162-trunk-v8.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-17 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14214939#comment-14214939
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12681946/hbase-5162-trunk-v7.patch
  against trunk revision .
  ATTACHMENT ID: 12681946

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:red}-1 patch{color}.  The patch command could not apply the patch.

Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11711//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-17 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14214998#comment-14214998
 ] 

Jesse Yates commented on HBASE-5162:


Latest changes to the RpcRetryingCaller are making me think that it might be 
cleaner to pull that into an interface and then let the factory decide what to 
do with it. That makes the StatsTrackingRpcRetryingCaller cleaner in that it 
just calls delegate methods and doesn't care about the underlying 
implementation.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, hbase-5162-trunk-v7.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-17 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14215046#comment-14215046
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12681962/hbase-5162-trunk-v8.patch
  against trunk revision .
  ATTACHMENT ID: 12681962

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:red}-1 javac{color}.  The patch appears to cause mvn compile goal to 
fail.

Compilation errors resume:
[ERROR] COMPILATION ERROR : 
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[211,59]
 no interface expected here
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[567,40]
 anonymous class implements interface; cannot have arguments
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[567,76]
 anonymous org.apache.hadoop.hbase.client.TestFastFailWithoutTestUtil$8 is 
not abstract and does not override abstract method 
callWithoutRetries(org.apache.hadoop.hbase.client.RetryingCallablejava.lang.Void,int)
 in org.apache.hadoop.hbase.client.RpcRetryingCaller
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[571,25]
 cannot find symbol
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[193,51]
 anonymous class implements interface; cannot have arguments
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[193,63]
 anonymous org.apache.hadoop.hbase.client.TestAsyncProcess$MyAsyncProcess$3 
is not abstract and does not override abstract method 
callWithRetries(org.apache.hadoop.hbase.client.RetryingCallableorg.apache.hadoop.hbase.client.MultiResponse,int)
 in org.apache.hadoop.hbase.client.RpcRetryingCaller
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[217,5]
 method does not override or implement a method from a supertype
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[234,14]
 incompatible types
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[297,51]
 anonymous class implements interface; cannot have arguments
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[297,63]
 anonymous 
org.apache.hadoop.hbase.client.TestAsyncProcess$MyAsyncProcessWithReplicas$2 
is not abstract and does not override abstract method 
callWithRetries(org.apache.hadoop.hbase.client.RetryingCallableorg.apache.hadoop.hbase.client.MultiResponse,int)
 in org.apache.hadoop.hbase.client.RpcRetryingCaller
[ERROR] Failed to execute goal 
org.apache.maven.plugins:maven-compiler-plugin:3.2:testCompile 
(default-testCompile) on project hbase-client: Compilation failure: Compilation 
failure:
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestAsyncProcess.java:[211,59]
 no interface expected here
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[567,40]
 anonymous class implements interface; cannot have arguments
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[567,76]
 anonymous org.apache.hadoop.hbase.client.TestFastFailWithoutTestUtil$8 is 
not abstract and does not override abstract method 
callWithoutRetries(org.apache.hadoop.hbase.client.RetryingCallablejava.lang.Void,int)
 in org.apache.hadoop.hbase.client.RpcRetryingCaller
[ERROR] 
/home/jenkins/jenkins-slave/workspace/PreCommit-HBASE-Build/hbase-client/src/test/java/org/apache/hadoop/hbase/client/TestFastFailWithoutTestUtil.java:[571,25]
 cannot find symbol
[ERROR] symbol: method 
callWithRetries(org.apache.hadoop.hbase.client.RetryingCallablejava.lang.Void,int)
[ERROR] 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-07 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14202694#comment-14202694
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12680247/hbase-5162-trunk-v6.patch
  against trunk revision .
  ATTACHMENT ID: 12680247

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:green}+1 checkstyle{color}.  The applied patch does not increase the 
total number of checkstyle errors

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:green}+1 lineLengths{color}.  The patch does not introduce lines 
longer than 100

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

 {color:red}-1 core tests{color}.  The patch failed these unit tests:
 

 {color:red}-1 core zombie tests{color}.  There are 1 zombie test(s):   
at 
org.apache.hadoop.hbase.http.TestHttpServerLifecycle.testStartedServerIsAlive(TestHttpServerLifecycle.java:71)

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//artifact/patchprocess/checkstyle-aggregate.html

  Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11615//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, 
 hbase-5162-trunk-v6.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-06 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14201372#comment-14201372
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12680022/hbase-5162-trunk-v5.patch
  against trunk revision .
  ATTACHMENT ID: 12680022

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:red}-1 checkstyle{color}.  The applied patch generated 
3792 checkstyle errors (more than the trunk's current 3782 errors).

{color:red}-1 findbugs{color}.  The patch appears to introduce 2 new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:red}-1 lineLengths{color}.  The patch introduces the following lines 
longer than 100:
+  return RpcRetryingCallerFactory.instantiate(conf, this.interceptor, 
this.getStatisticsTracker());
+  new java.lang.String[] { Index, Result, Exception, 
ServiceResult, LoadStats, });

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

 {color:red}-1 core tests{color}.  The patch failed these unit tests:
   org.apache.hadoop.hbase.client.TestClientNoCluster
  org.apache.hadoop.hbase.client.TestAsyncProcess

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//artifact/patchprocess/checkstyle-aggregate.html

Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11610//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, hbase-5162-trunk-v5.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-05 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14199330#comment-14199330
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12679628/hbase-5162-trunk-v4.patch
  against trunk revision .
  ATTACHMENT ID: 12679628

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:green}+1 javadoc{color}.  The javadoc tool did not generate any 
warning messages.

{color:green}+1 checkstyle{color}.  The applied patch does not increase the 
total number of checkstyle errors

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:red}-1 lineLengths{color}.  The patch introduces the following lines 
longer than 100:
+  return RpcRetryingCallerFactory.instantiate(conf, this.interceptor, 
this.getStatisticsTracker());
+  new java.lang.String[] { Index, Result, Exception, 
ServiceResult, LoadStats, });

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

{color:green}+1 core tests{color}.  The patch passed unit tests in .

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//artifact/patchprocess/checkstyle-aggregate.html

  Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11596//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-05 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14199497#comment-14199497
 ] 

Jesse Yates commented on HBASE-5162:


Ok, thats good enough for a review. Updated diff: 
https://reviews.apache.org/r/27436/. Maybe if you have some time [~apurtell] or 
[~lhofhansl]?

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, hbase-5162-trunk-v3.patch, 
 hbase-5162-trunk-v4.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-04 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14196914#comment-14196914
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12679302/hbase-5162-trunk-v2.patch
  against trunk revision .
  ATTACHMENT ID: 12679302

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:red}-1 javac{color}.  The applied patch generated 103 javac compiler 
warnings (more than the trunk's current 102 warnings).

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:red}-1 javadoc{color}.  The javadoc tool appears to have generated 1 
warning messages.

{color:red}-1 checkstyle{color}.  The applied patch generated 
3791 checkstyle errors (more than the trunk's current 3782 errors).

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:green}+1 release audit{color}.  The applied patch does not increase 
the total number of release audit warnings.

{color:red}-1 lineLengths{color}.  The patch introduces the following lines 
longer than 100:
+  return RpcRetryingCallerFactory.instantiate(conf, this.interceptor, 
this.getStatisticsTracker());
+String className = conf.get(BACKOFF_POLICY_CLASS, 
ExponentialClientBackoffPolicy.class.getName());
+  new java.lang.String[] { Index, Result, Exception, 
ServiceResult, LoadStats, });

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

 {color:red}-1 core tests{color}.  The patch failed these unit tests:
   
org.apache.hadoop.hbase.mapreduce.TestSecureLoadIncrementalHFilesSplitRecovery

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//testReport/
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/checkstyle-aggregate.html

Javadoc warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//artifact/patchprocess/patchJavadocWarnings.txt
Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11583//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 hbase-5162-trunk-v2.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-03 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14195304#comment-14195304
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12678516/hbase-5162-trunk-v0.patch
  against trunk revision .
  ATTACHMENT ID: 12678516

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:red}-1 patch{color}.  The patch command could not apply the patch.

Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11572//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-11-03 Thread Hadoop QA (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14195616#comment-14195616
 ] 

Hadoop QA commented on HBASE-5162:
--

{color:red}-1 overall{color}.  Here are the results of testing the latest 
attachment 
  
http://issues.apache.org/jira/secure/attachment/12679098/hbase-5162-trunk-v1.patch
  against trunk revision .
  ATTACHMENT ID: 12679098

{color:green}+1 @author{color}.  The patch does not contain any @author 
tags.

{color:green}+1 tests included{color}.  The patch appears to include 7 new 
or modified tests.

{color:red}-1 javac{color}.  The applied patch generated 103 javac compiler 
warnings (more than the trunk's current 102 warnings).

{color:green}+1 javac{color}.  The applied patch does not increase the 
total number of javac compiler warnings.

{color:red}-1 javadoc{color}.  The javadoc tool appears to have generated 2 
warning messages.

{color:red}-1 checkstyle{color}.  The applied patch generated 
3797 checkstyle errors (more than the trunk's current 3781 errors).

{color:green}+1 findbugs{color}.  The patch does not introduce any new 
Findbugs (version 2.0.3) warnings.

{color:red}-1 release audit{color}.  The applied patch generated 7 release 
audit warnings (more than the trunk's current 0 warnings).

{color:red}-1 lineLengths{color}.  The patch introduces the following lines 
longer than 100:
+  return RpcRetryingCallerFactory.instantiate(conf, this.interceptor, 
this.getStatisticsTracker());
+// even if we get interrupted here, but for now, we still need to run so 
we decrement the outstanding tasks
+String className = conf.get(BACKOFF_POLICY_CLASS, 
ExponentialClientBackoffPolicy.class.getName());
+  new java.lang.String[] { Index, Result, Exception, 
ServiceResult, LoadStats, });

  {color:green}+1 site{color}.  The mvn site goal succeeds with this patch.

 {color:red}-1 core tests{color}.  The patch failed these unit tests:
   
org.apache.hadoop.hbase.regionserver.TestRegionServerNoMaster
  org.apache.hadoop.hbase.master.TestSplitLogManager

Test results: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//testReport/
Release audit warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/patchReleaseAuditWarnings.txt
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-examples.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-prefix-tree.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-server.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-client.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-protocol.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-hadoop2-compat.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-rest.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-thrift.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-annotations.html
Findbugs warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/newPatchFindbugsWarningshbase-common.html
Checkstyle Errors: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/checkstyle-aggregate.html

Javadoc warnings: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//artifact/patchprocess/patchJavadocWarnings.txt
Console output: 
https://builds.apache.org/job/PreCommit-HBASE-Build/11573//console

This message is automatically generated.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
Assignee: Jesse Yates
 Fix For: 1.0.0

 Attachments: hbase-5162-trunk-v0.patch, hbase-5162-trunk-v1.patch, 
 java_HBASE-5162.patch


 The current blocking we do when we are close to some limits 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-10-31 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14192226#comment-14192226
 ] 

Jesse Yates commented on HBASE-5162:


Review request here: https://reviews.apache.org/r/27436/

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Attachments: hbase-5162-trunk-v0.patch, java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.3.4#6332)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2014-05-20 Thread Nicolas Liochon (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=14004340#comment-14004340
 ] 

Nicolas Liochon commented on HBASE-5162:


Arriving from HBASE-11208, we could:
 - accept the write as mentioned by jesse
 - return a load status (something like a number between 0 and 100, maybe two 
figures for the region and the regionserver), the client can then use this to 
slowdown. The AsyncProcess would ease this.



 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?



--
This message was sent by Atlassian JIRA
(v6.2#6252)


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jimmy Xiang (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482767#comment-13482767
 ] 

Jimmy Xiang commented on HBASE-5162:


Isn't the exception way much cleaner and simpler?  I think the exception way is 
greedy, and the hbase client code needs minimal change. Based on the retry 
count, it can adjust the delay time in the middle.

For the load monitoring, we assume the load trend remains the same, which may 
not be that case actually. The client side has to track the regions whose 
memstore is under pressure.  Every client needs to do the same tracking.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482785#comment-13482785
 ] 

Jesse Yates commented on HBASE-5162:


[~jxiang] not really - the exception causes old clients to fail and uses 
exception type inheritance + instanceof checking to get the information across. 
The client code does need minimal change (see my attached patch), but it just 
feels _dirty_, especially when we have PBs for everythign. What would be far 
better is just pass that info back as an optional PB parameter and have the 
client monitor it or not. This both works the the older versions AND optionally 
turning it off on the client if your workload needs it. the workload doesn't 
stay the same - the client gets constant information (at least with each 
mutation across the wire) back from the region and adjusts as it's updated.

 So yeah, every client that has this enabled would have to track the 
information. But you could make it that you just track the most recent 'n' 
regions. And an advanced version would also do some load half-life mechanism on 
the client if it hasn't talked to that region in a while.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Lars Hofhansl (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482787#comment-13482787
 ] 

Lars Hofhansl commented on HBASE-5162:
--

We could just throw a ServerTooBusyException (or something), which would extend 
IOException, so the client would just retry. However after a while then the 
client would fail, when it should just wait longer.
No sure how much better that would than it is now, though. It would be better 
to gradually slow clients down, so that they still make progress but only as 
fast as the system can absorb it.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482816#comment-13482816
 ] 

Jesse Yates commented on HBASE-5162:


The problem with throwing just another IOException with the default client is 
that the client thinks its writes failed, in which it retries, causing MORE 
load on the already overloaded server. You'd have to hack the client a bit, 
which means that still on 0.94 you get the retry behaviour

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482822#comment-13482822
 ] 

Jesse Yates commented on HBASE-5162:


I tried to tackle this doing the PB way a little while ago (though it may have 
been in conjunction with some other ticket that I don't recall at the moment) 
and you basically need to rewrite how the client does batch puts to allow you 
to actually get at the returned PB object, rather than having it pass the 
callback the underlying errors/rows. IIRC this wasn't super clean as the code 
there is very convoluted. However, you can tie it into the other mutation 
methods really easily as just a hook on the serverCallable. 

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jimmy Xiang (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482827#comment-13482827
 ] 

Jimmy Xiang commented on HBASE-5162:


I was thinking RegionTooBusyException, so close. As long as the server releases 
the IPC handler in such scenario, accessing other regions should not be 
blocked.  The point is that we don't want a busy region blocks a whole region 
server.

As to the old clients, right, the behavior is a little different.  But they 
should not fail, as currently they should expect exceptions and handle them 
properly, for example, retry, although it may not be as efficient as delaying 
more when the retry count is bigger.

As to measure the load, I think it is a good idea.  I just have some concern in 
spending too much efforts on it without trying the simple one at first, which 
is known to work.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jimmy Xiang (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482829#comment-13482829
 ] 

Jimmy Xiang commented on HBASE-5162:


For the extra load due to retry, it is mostly on network, not very much on the 
server.  The retry time is configurable based on the tries:

ConnectionUtils.getPauseTime(pause, tries)

As long as the retry is gradually slowing down, is it acceptable?


 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482831#comment-13482831
 ] 

Jesse Yates commented on HBASE-5162:


[~jxiang] my patch is up there, if you want to run with it.. I'm a bit busy at 
the moment :)

{quote}
The client has also been given permission to grow to a multiplier of its 
writeBufferSize, similar to the memstoremultiplier, allowing it to buffer more 
writes. If a write is within the expansion range, we want to allow the client 
to accept more writes while waiting/backing-off, so we launch a flusher thread 
that after waiting the backoff time will flush the writes (singleton). This 
gives us back-off as well as some flexiblilty on the client as to how much we 
buffer. To disable the backoff behavior, its as simple as setting the 
multiplier to 1, so the expansion = max.

-Jesse
{quote}

I don't this is really the right way to handle this, but instead just plug in 
the wait-object per region that ties in the most recent information. Also, from 
the above, using a MonitoredResult rather than throwing an exception ensures 
the same behavior on old and new clients. Its ugly, but as long as you put in a 
TODO, I'm okay with it.

You might need to rewrite a bit of my patch - there are probably some good 
hints as to the right places to hook in code, but I think just having the 
clients that 'care' wait will be good enough for now. The addition of the 
server waiting is a bad idea as it has a much larger effect on the system as a 
whole.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-10-23 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13482832#comment-13482832
 ] 

Jesse Yates commented on HBASE-5162:


My concern is that the retry is completely a waste - just accept the write and 
then slow it down later. Otherwise you are resending the data a lot more than 
necessary, which is going to put more network load (especially with large puts) 
than you need, possibly multiple times over.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators
For more information on JIRA, see: http://www.atlassian.com/software/jira


[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-06-16 Thread Jesse Yates (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13393385#comment-13393385
 ] 

Jesse Yates commented on HBASE-5162:


@Lars not yet - needs some more testing and validation on a real cluster. I've 
been a bit busy and haven't got a chance to swing back around.

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.96.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: 
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira




[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-21 Thread jirapos...@reviews.apache.org (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13212781#comment-13212781
 ] 

jirapos...@reviews.apache.org commented on HBASE-5162:
--



bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/regionserver/StoreUtils.java, line 
7
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75496#file75496line7
bq.  
bq.   General comment: Where are we on putting/documenting these things in 
hbase-defaults.xml?

That is already in there, but having the constants just reinforces the 
'correct' behavior. Though I think there are some situations where the code is 
different from defaults.xml


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   
src/main/java/org/apache/hadoop/hbase/regionserver/MemstorePressureMonitor.java,
 line 124
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75492#file75492line124
bq.  
bq.   Ah ok, this is where we gracefully delay the server thread a bit.
bq.   Seems this would need to be tweaked carefully to make it effective 
while not slowing normal operations.
bq.   
bq.   Should the serverPauseTime be somehow related to the amount of 
pressure.
bq.   I.e. wait a bit more if the pressure is higher?
bq.   Maybe the pausetime calculation should be part of the pluggable 
policy?
bq.   
bq.   Also in the jira there was some discussion about throwing 
(presumably retryable) exceptions back to the client is the pressure gets too 
high. That would slow the client, without consuming server resources (beyond 
multiple requests).

Definitely needs some knobs with the policy here and tuning.

It would be possible to tie the pause time to the amount of pressure (some sort 
of multiplier effect). Would have to think about the implications of that

Throwing the exception back the client here means you get a lot of bandwidth 
overhead as the client passes back a bunch of puts _again_, which is rough. 
Otherwise, we are *definitely* going to be messing with wire-compatibility in a 
functional (if not strictly RPC) sense.


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/client/HTable.java, line 979
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75487#file75487line979
bq.  
bq.   This will break backwards compatibility, right? (Not saying that's 
not ok, just calling it out)
bq.   
bq.   I'd almost rather have the client not know about this, until we 
reach a bad spot (in which case we can throw back retryable exceptions).

I don't think so. If the server isn't upgraded to the send monitoredResults, 
then this bit of code won't matter. If the client isn't upgraded, then it won't 
even consider if the MonitoredResult isn't just a Result.


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/client/HTable.java, line 958
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75487#file75487line958
bq.  
bq.   Was this a problem before? Or only now becaue of the background 
thread?

Just b/c of the background thread.


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/client/HTable.java, line 792
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75487#file75487line792
bq.  
bq.   If sleepTime is 0 (for example from NoServerBackoffPolicy), we 
should probably not create the thread and flush right here.
bq.   
bq.   (But as I said in the comment above, I'd probably not bother with 
this extra thread to begin with :) )

+1 fixing in next version, assuming the client stuff is kept


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/client/HTable.java, line 791
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75487#file75487line791
bq.  
bq.   What if the flusher is not null? Should we re-calculate the wait 
time?

We are temporarily growing the write buffer, so if we get another write, I was 
thinking we would just let it accumulate too - it will get flushed soon enough. 
Only corner case here is if the size grows beyond the allowed, in which case 
there will be a forced flush.


bq.  On 2012-02-18 04:58:21, Lars Hofhansl wrote:
bq.   src/main/java/org/apache/hadoop/hbase/client/HTable.java, line 790
bq.   https://reviews.apache.org/r/3930/diff/1/?file=75487#file75487line790
bq.  
bq.   I find this a bit dubious.
bq.   This won't actually slow the client thread down, but just accumulate 
more data and reduce the number of RPCs. In the end it might lead to more load 
on the server, because we can deliver more puts as with fewer but larger 
batches.
bq.   
bq.   I'd rather just rely on the server sleeping the thread for a bit (as 
you do later).

The question here is what we consider the 'client'. To me, the client was the 
client-side HTable, not the 

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-17 Thread jirapos...@reviews.apache.org (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13210809#comment-13210809
 ] 

jirapos...@reviews.apache.org commented on HBASE-5162:
--


---
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/3930/#review5209
---



src/main/java/org/apache/hadoop/hbase/client/HTable.java
https://reviews.apache.org/r/3930/#comment11397

I find this a bit dubious.
This won't actually slow the client thread down, but just accumulate more 
data and reduce the number of RPCs. In the end it might lead to more load on 
the server, because we can deliver more puts as with fewer but larger batches.

I'd rather just rely on the server sleeping the thread for a bit (as you do 
later).



src/main/java/org/apache/hadoop/hbase/client/HTable.java
https://reviews.apache.org/r/3930/#comment11399

What if the flusher is not null? Should we re-calculate the wait time?



src/main/java/org/apache/hadoop/hbase/client/HTable.java
https://reviews.apache.org/r/3930/#comment11400

If sleepTime is 0 (for example from NoServerBackoffPolicy), we should 
probably not create the thread and flush right here.

(But as I said in the comment above, I'd probably not bother with this 
extra thread to begin with :) )



src/main/java/org/apache/hadoop/hbase/client/HTable.java
https://reviews.apache.org/r/3930/#comment11401

Was this a problem before? Or only now becaue of the background thread?



src/main/java/org/apache/hadoop/hbase/client/HTable.java
https://reviews.apache.org/r/3930/#comment11398

This will break backwards compatibility, right? (Not saying that's not ok, 
just calling it out)

I'd almost rather have the client not know about this, until we reach a bad 
spot (in which case we can throw back retryable exceptions).



src/main/java/org/apache/hadoop/hbase/regionserver/MemstorePressureMonitor.java
https://reviews.apache.org/r/3930/#comment11402

Ah ok, this is where we gracefully delay the server thread a bit.
Seems this would need to be tweaked carefully to make it effective while 
not slowing normal operations.

Should the serverPauseTime be somehow related to the amount of pressure.
I.e. wait a bit more if the pressure is higher?
Maybe the pausetime calculation should be part of the pluggable policy?

Also in the jira there was some discussion about throwing (presumably 
retryable) exceptions back to the client is the pressure gets too high. That 
would slow the client, without consuming server resources (beyond multiple 
requests).



src/main/java/org/apache/hadoop/hbase/regionserver/StoreUtils.java
https://reviews.apache.org/r/3930/#comment11403

General comment: Where are we on putting/documenting these things in 
hbase-defaults.xml?


- Lars


On 2012-02-16 20:45:50, Jesse Yates wrote:
bq.  
bq.  ---
bq.  This is an automatically generated e-mail. To reply, visit:
bq.  https://reviews.apache.org/r/3930/
bq.  ---
bq.  
bq.  (Updated 2012-02-16 20:45:50)
bq.  
bq.  
bq.  Review request for hbase, Michael Stack, Jean-Daniel Cryans, and Lars 
Hofhansl.
bq.  
bq.  
bq.  Summary
bq.  ---
bq.  
bq.  Under heavy write load, HBase will create a saw-tooth pattern in accepting 
writes. This is due to the I/O in minor compactions not being able to keep up 
with the write load. Specifically, the memstore is attempting to flush while we 
are attempting to do a minor compaction, leading to blocking _all_ writes. 
Instead, we need to have the option of graceful degradation mechanism.
bq.  
bq.  This patch supports both a short-term,adjustable server-side write 
blocking as well as client-side back-off to help alleviate temporary memstore 
pressure.
bq.  
bq.  
bq.  This addresses bug HBASE-5162.
bq.  https://issues.apache.org/jira/browse/HBASE-5162
bq.  
bq.  
bq.  Diffs
bq.  -
bq.  
bq.src/main/java/org/apache/hadoop/hbase/HConstants.java 763fe89 
bq.src/main/java/org/apache/hadoop/hbase/client/BackoffPolicy.java 
PRE-CREATION 
bq.src/main/java/org/apache/hadoop/hbase/client/HTable.java 57605e6 
bq.src/main/java/org/apache/hadoop/hbase/client/MonitoredResult.java 
PRE-CREATION 
bq.src/main/java/org/apache/hadoop/hbase/client/NoServerBackoffPolicy.java 
PRE-CREATION 
bq.src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java 25cb31d 
bq.src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java 
7d7be3c 
bq.
src/main/java/org/apache/hadoop/hbase/regionserver/MemstorePressureMonitor.java 
PRE-CREATION 
bq.src/main/java/org/apache/hadoop/hbase/regionserver/OperationStatus.java 
1b94ab5 
bq.

[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-16 Thread Lars Hofhansl (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13209715#comment-13209715
 ] 

Lars Hofhansl commented on HBASE-5162:
--

Might be good to publish on review board, that patch is a bit big to read as 
diff :)

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.94.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: 
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira




[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-16 Thread Jesse Yates (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13209718#comment-13209718
 ] 

Jesse Yates commented on HBASE-5162:


@lars - can do. I didn't want it up there initially as that tends to find a lot 
of nitpicks, which this patch I'm sure has lots of ;)

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.94.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: 
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira




[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-16 Thread jirapos...@reviews.apache.org (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13209725#comment-13209725
 ] 

jirapos...@reviews.apache.org commented on HBASE-5162:
--


---
This is an automatically generated e-mail. To reply, visit:
https://reviews.apache.org/r/3930/
---

Review request for hbase, Michael Stack, Jean-Daniel Cryans, and Lars Hofhansl.


Summary
---

Under heavy write load, HBase will create a saw-tooth pattern in accepting 
writes. This is due to the I/O in minor compactions not being able to keep up 
with the write load. Specifically, the memstore is attempting to flush while we 
are attempting to do a minor compaction, leading to blocking _all_ writes. 
Instead, we need to have the option of graceful degradation mechanism.

This patch supports both a short-term,adjustable server-side write blocking as 
well as client-side back-off to help alleviate temporary memstore pressure.


This addresses bug HBASE-5162.
https://issues.apache.org/jira/browse/HBASE-5162


Diffs
-

  src/main/java/org/apache/hadoop/hbase/HConstants.java 763fe89 
  src/main/java/org/apache/hadoop/hbase/client/BackoffPolicy.java PRE-CREATION 
  src/main/java/org/apache/hadoop/hbase/client/HTable.java 57605e6 
  src/main/java/org/apache/hadoop/hbase/client/MonitoredResult.java 
PRE-CREATION 
  src/main/java/org/apache/hadoop/hbase/client/NoServerBackoffPolicy.java 
PRE-CREATION 
  src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java 25cb31d 
  src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java 7d7be3c 
  
src/main/java/org/apache/hadoop/hbase/regionserver/MemstorePressureMonitor.java 
PRE-CREATION 
  src/main/java/org/apache/hadoop/hbase/regionserver/OperationStatus.java 
1b94ab5 
  src/main/java/org/apache/hadoop/hbase/regionserver/PressureMonitor.java 
PRE-CREATION 
  
src/main/java/org/apache/hadoop/hbase/regionserver/SimpleMemStorePressureMonitor.java
 PRE-CREATION 
  src/main/java/org/apache/hadoop/hbase/regionserver/StoreUtils.java 
PRE-CREATION 
  src/test/java/org/apache/hadoop/hbase/client/TestClientBackOff.java 
PRE-CREATION 
  
src/test/java/org/apache/hadoop/hbase/regionserver/TestMemStorePressureMonitor.java
 PRE-CREATION 

Diff: https://reviews.apache.org/r/3930/diff


Testing
---


Thanks,

Jesse



 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.94.0

 Attachments: java_HBASE-5162.patch


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: 
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira




[jira] [Commented] (HBASE-5162) Basic client pushback mechanism

2012-02-13 Thread Lars Hofhansl (Commented) (JIRA)

[ 
https://issues.apache.org/jira/browse/HBASE-5162?page=com.atlassian.jira.plugin.system.issuetabpanels:comment-tabpanelfocusedCommentId=13207068#comment-13207068
 ] 

Lars Hofhansl commented on HBASE-5162:
--

The exception part is nice, because it works without touching RPC.

I wonder if that should be a phased approach?
I.e. if there is light pressure, just delay the operations in the server 
threads (uses up server threads and memory, but will be transparent to the 
client, who will just see a slightly less performant server).
When the pressure gets higher despite the server delays, we'd throw exceptions 
back to the client, and if that is not enough we block as we do now.

The interesting part is: How exactly would we measure the pressure? Based on 
the number of a storefiles and the current rate of updates?

 Basic client pushback mechanism
 ---

 Key: HBASE-5162
 URL: https://issues.apache.org/jira/browse/HBASE-5162
 Project: HBase
  Issue Type: New Feature
Affects Versions: 0.92.0
Reporter: Jean-Daniel Cryans
 Fix For: 0.94.0


 The current blocking we do when we are close to some limits (memstores over 
 the multiplier factor, too many store files, global memstore memory) is bad, 
 too coarse and confusing. After hitting HBASE-5161, it really becomes obvious 
 that we need something better.
 I did a little brainstorm with Stack, we came up quickly with two solutions:
  - Send some exception to the client, like OverloadedException, that's thrown 
 when some situation happens like getting past the low memory barrier. It 
 would be thrown when the client gets a handler and does some check while 
 putting or deleting. The client would treat this a retryable exception but 
 ideally wouldn't check .META. for a new location. It could be fancy and have 
 multiple levels of pushback, like send the exception to 25% of the clients, 
 and then go up if the situation persists. Should be easy to implement but 
 we'll be using a lot more IO to send the payload over and over again (but at 
 least it wouldn't sit in the RS's memory).
  - Send a message alongside a successful put or delete to tell the client to 
 slow down a little, this way we don't have to do back and forth with the 
 payload between the client and the server. It's a cleaner (I think) but more 
 involved solution.
 In every case the RS should do very obvious things to notify the operators of 
 this situation, through logs, web UI, metrics, etc.
 Other ideas?

--
This message is automatically generated by JIRA.
If you think it was sent incorrectly, please contact your JIRA administrators: 
https://issues.apache.org/jira/secure/ContactAdministrators!default.jspa
For more information on JIRA, see: http://www.atlassian.com/software/jira