-----------------------------------------------------------
This is an automatically generated e-mail. To reply, visit:
http://review.cloudera.org/r/816/#review1414
-----------------------------------------------------------


I got as far as ipc and then stopped for now.

Really impressive Gary.  Pity its so ugly (Not your fault that ipc -- Call, 
Invoke, etc. -- and Proxy interface is so).  But it looks like the needed 
flexibility is there -- and it'll work.



src/main/java/org/apache/hadoop/hbase/client/Action.java
<http://review.cloudera.org/r/816/#comment4874>

    Action is a new class so we are not breaking any pre-exisiting API here 
(Even so, erasure would reduce this API change to the old I believe anyways?).
    



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4882>

    I think the fact that this class if of coprocessors needs to be highlighted 
better.  Batch is a super generic name yet this Batch is only for CPs.  A 
subpackage for these CP classes would be a pain would it?  Any other way of 
grouping these CP classes?  A prefix?  Just throwing it out there (I'm sure you 
thought about it and had a reason for not going these routes).



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4875>

    cool
    
    But, this method's name is 'returning'?
    
    So, it executes the 'method' of 'protocol' and returns the hosting  'Call' 
whose invocation has already run?
    
    Should it be 'execute' or 'executeCall' or 'invokeCall', etc.



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4876>

    Nice



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4877>

    Do you need the 'Batch.' prefix here?



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4878>

    good
    
    (but of interest, how does this differ from setCause?  Or, could you pass 
the ite to the IOE constructor?



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4880>

    Good javadoc.



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4881>

    Should this method be 'public' since its only called in here -- whats 
returned out of a 'returning' is an exhausted call.. the receiving caller will 
not be doing a call invocation?



src/main/java/org/apache/hadoop/hbase/client/Batch.java
<http://review.cloudera.org/r/816/#comment4879>

    I don't see Callback passed to call in the above.  I suppose how Callback 
works will become clear later.



src/main/java/org/apache/hadoop/hbase/client/Exec.java
<http://review.cloudera.org/r/816/#comment4883>

    ... against a Coprocessor?
    
    Maybe add above?
    



src/main/java/org/apache/hadoop/hbase/client/Exec.java
<http://review.cloudera.org/r/816/#comment4884>

    This is fair I suppose if only one coprocessor per region (Is that true)?



src/main/java/org/apache/hadoop/hbase/client/ExecResult.java
<http://review.cloudera.org/r/816/#comment4885>

    This class is for CPs only?



src/main/java/org/apache/hadoop/hbase/client/HConnection.java
<http://review.cloudera.org/r/816/#comment4886>

    Want to call this out as a CP method?
    



src/main/java/org/apache/hadoop/hbase/client/HConnection.java
<http://review.cloudera.org/r/816/#comment4887>

    Cool
    
    So this would be for a single cooprocessor implementation. 
    
    You say above that we do an rpc per row but are the rpcs run serially or in 
parallell?  If parallel, thats sweet.



src/main/java/org/apache/hadoop/hbase/client/HConnection.java
<http://review.cloudera.org/r/816/#comment4888>

    So, here is a case where row designates a region, right?  Not a 'row'.  If 
all these CP classes were in a sub-package, you could do a package-info on CP 
w/ examples, etc. -- copy/paste of the stuff you have above?



src/main/java/org/apache/hadoop/hbase/client/HConnection.java
<http://review.cloudera.org/r/816/#comment4889>

    I thought the client pollution would be worse than it is.



src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java
<http://review.cloudera.org/r/816/#comment4890>

    Whats going on here?  You are rigging the createCallable so it can be used 
by CPs?
    
    (no objection, just asking)



src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java
<http://review.cloudera.org/r/816/#comment4891>

    Should this be public?  Its not in HConnection, is it?  Or, rather, why is 
it not in HConnection?



src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java
<http://review.cloudera.org/r/816/#comment4892>

    Again, this is rigging MultiAction to support the CP parameterized types?



src/main/java/org/apache/hadoop/hbase/client/HTable.java
<http://review.cloudera.org/r/816/#comment4893>

    OK.  This is a nice explaination.  Good doc.



src/main/java/org/apache/hadoop/hbase/client/HTable.java
<http://review.cloudera.org/r/816/#comment4894>

    What if I pass more than one key for a region?  Will CP run twice?



src/main/java/org/apache/hadoop/hbase/client/HTableInterface.java
<http://review.cloudera.org/r/816/#comment4895>

    oh, you don't have to repeat this doc up in HTable.  I'd remove it and 
replace it '@Override'.



src/main/java/org/apache/hadoop/hbase/client/MultiResponse.java
<http://review.cloudera.org/r/816/#comment4896>

    This all looks like an improvement.



src/main/java/org/apache/hadoop/hbase/client/RowRange.java
<http://review.cloudera.org/r/816/#comment4897>

    You have to say something about 'inclusive'?


- stack


On 2010-10-04 16:28:39, Gary Helmling wrote:
> 
> -----------------------------------------------------------
> This is an automatically generated e-mail. To reply, visit:
> http://review.cloudera.org/r/816/
> -----------------------------------------------------------
> 
> (Updated 2010-10-04 16:28:39)
> 
> 
> Review request for hbase, Andrew Purtell and Jonathan Gray.
> 
> 
> Summary
> -------
> 
> This is really two separate patches in one, though with some overlapping 
> changes.  If necessary I can split them apart for separate review.  Please 
> let me know if that would make review easier.
> 
> Part 1:
> ==============
> Port over of HADOOP-6422 to the HBase RPC code.  The goal of this change is 
> to allow alternate RPC client/server implementations to be enabled through a 
> simple configuration change.  Ultimately I would like to use this to allow 
> secure RPC to be enabled through configuration, while not blocking normal 
> (current) RPC operation on non-secure Hadoop versions.
> 
> This portion of the patch abstracts out two interfaces from the RPC code:
> 
> RpcEngine: HBaseRPC uses this to obtain proxy instances for client calls and 
> server instances for HMaster and HRegionServer
> RpcServer: this allows differing RPC server implementations, breaking the 
> dependency on HBaseServer
> 
> The bulk of the current code from HBaseRPC is moved into WritableRpcEngine 
> and is unchanged other than the interface requirements.  So the current call 
> path remains the same, other than the HBaseRPC.getProtocolEngine() 
> abstraction.
> 
> 
> Part 2:
> ===============
> The remaining changes provide server-side hooks for registering new RPC 
> protocols/handlers (per-region to support coprocessors), and client side 
> hooks to support dynamic execution of the registered protocols.
> 
> The new RPC protocol actions are constrained to 
> org.apache.hadoop.hbase.ipc.CoprocessorProtocol implementations (which 
> extends VersionedProtocol) to prevent arbitrary execution of methods against 
> HMasterInterface, HRegionInterface, etc.
> 
> For protocol handler registration, HRegionServer provides a new method:
> 
>   public <T extends CoprocessorProtocol> boolean registerProtocol(
>       byte[] region, Class<T> protocol, T handler)
> 
> which builds a Map of region name to protocol instances for dispatching 
> client calls.
> 
> 
> Client invocations are performed through HTable, which adds the following 
> methods:
> 
> 
>   public <T extends CoprocessorProtocol> T proxy(Class<T> protocol, Row row)
> 
> This directly returns a proxy instance to the CoprocessorProtocol 
> implementation registered for the region serving row "row".  Any method calls 
> will be proxied to the region's server and invoked using the map of 
> registered region name -> handler instances.
> 
> Calls directed against multiple rows are a bit more complicated.  They are 
> supported with the methods:
> 
>   public <T extends CoprocessorProtocol, R> void exec(
>       Class<T> protocol, List<? extends Row> rows,
>       BatchCall<T,R> callable, BatchCallback<R> callback)
> 
>   public <T extends CoprocessorProtocol, R> void exec(
>       Class<T> protocol, RowRange range,
>       BatchCall<T,R> callable, BatchCallback<R> callback)
> 
> where BatchCall and BatchCallback are simple interfaces defining the methods 
> to be called and a callback instance to be invoked for each result.
> 
> For the sample CoprocessorProtocol interface:
> 
>   interface PingProtocol extends CoprocessorProtocol {
>     public String ping();
>     public String hello(String name);
>   }
> 
> a client invocation might look like:
> 
>     final Map<byte[],R> results = new TreeMap<byte[],R>(...)
>     List<Row> rows = ...
>     table.exec(PingProtocol.class, rows,
>         new HTable.BatchCall<PingProtocol,String>() {
>           public String call(PingProtocol instance) {
>             return instance.ping();
>           }
>         },
>         new BatchCallback<R>(){
>           public void update(byte[] region, byte[] row, R value) {
>             results.put(region, value);
>           }
>         });
> 
> The BatchCall.call() method will be invoked for each row in the passed in 
> list, and the BatchCallback.update() method will be invoked for each return 
> value.  However, currently the PingProtocol.ping() invocation will result in 
> a separate RPC call per row, which is less that ideal.
> 
> Support is in place to make use of the HRegionServer.multi() invocations for 
> batched RPC (see the org.apache.hadoop.hbase.client.Exec class), but this 
> does not mesh well with the current client-side interface.
> 
> In addition to standard code review, I'd appreciate any thoughts on the 
> client interactions in particular, and whether they would meet some of the 
> anticipated uses of coprocessors.
> 
> 
> This addresses bug HBASE-2002.
>     http://issues.apache.org/jira/browse/HBASE-2002
> 
> 
> Diffs
> -----
> 
>   src/main/java/org/apache/hadoop/hbase/client/Action.java 556ea81 
>   src/main/java/org/apache/hadoop/hbase/client/Batch.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/client/Exec.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/client/ExecResult.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/client/HConnection.java 65f7618 
>   src/main/java/org/apache/hadoop/hbase/client/HConnectionManager.java 
> 866ba92 
>   src/main/java/org/apache/hadoop/hbase/client/HTable.java 0dbf263 
>   src/main/java/org/apache/hadoop/hbase/client/HTableInterface.java 74593bf 
>   src/main/java/org/apache/hadoop/hbase/client/MultiAction.java c6ea838 
>   src/main/java/org/apache/hadoop/hbase/client/MultiResponse.java 91bd04b 
>   src/main/java/org/apache/hadoop/hbase/client/RowRange.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/client/Scan.java 29b3cb0 
>   src/main/java/org/apache/hadoop/hbase/io/HbaseObjectWritable.java 83f623d 
>   src/main/java/org/apache/hadoop/hbase/ipc/ConnectionHeader.java 
> PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/CoprocessorProtocol.java 
> PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/ExecRPCInvoker.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/HBaseClient.java 2b5eeb6 
>   src/main/java/org/apache/hadoop/hbase/ipc/HBaseRPC.java e23a629 
>   src/main/java/org/apache/hadoop/hbase/ipc/HBaseServer.java e4c356d 
>   src/main/java/org/apache/hadoop/hbase/ipc/HRegionInterface.java ee5dd8f 
>   src/main/java/org/apache/hadoop/hbase/ipc/Invocation.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/RpcEngine.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/RpcServer.java PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/ipc/WritableRpcEngine.java 
> PRE-CREATION 
>   src/main/java/org/apache/hadoop/hbase/master/HMaster.java fb1e834 
>   src/main/java/org/apache/hadoop/hbase/regionserver/HRegion.java 0a4fbce 
>   src/main/java/org/apache/hadoop/hbase/regionserver/HRegionServer.java 
> 89f499a 
>   src/main/java/org/apache/hadoop/hbase/rest/client/RemoteHTable.java d4166cf 
>   src/main/resources/hbase-default.xml 5fafe65 
>   
> src/test/java/org/apache/hadoop/hbase/regionserver/TestServerCustomProtocol.java
>  PRE-CREATION 
> 
> Diff: http://review.cloudera.org/r/816/diff
> 
> 
> Testing
> -------
> 
> 
> Thanks,
> 
> Gary
> 
>

Reply via email to