[22/23] accumulo git commit: Merge branch '1.6' into 1.7

[el...@apache.org]

Merge branch '1.6' into 1.7


Project: http://git-wip-us.apache.org/repos/asf/accumulo/repo
Commit: http://git-wip-us.apache.org/repos/asf/accumulo/commit/e35e1898
Tree: http://git-wip-us.apache.org/repos/asf/accumulo/tree/e35e1898
Diff: http://git-wip-us.apache.org/repos/asf/accumulo/diff/e35e1898

Branch: refs/heads/master
Commit: e35e1898d0c8f4c2daad822b1d2514ed22fddf75
Parents: f898a6b 5724df5
Author: Josh Elser <el...@apache.org>
Authored: Tue Dec 1 21:19:55 2015 -0500
Committer: Josh Elser <el...@apache.org>
Committed: Tue Dec 1 21:20:12 2015 -0500

----------------------------------------------------------------------
 .../main/java/org/apache/accumulo/proxy/Proxy.java   |  1 -
 .../apache/accumulo/server/rpc/RpcWrapperTest.java   | 15 +++++++++++++++
 2 files changed, 15 insertions(+), 1 deletion(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/accumulo/blob/e35e1898/proxy/src/main/java/org/apache/accumulo/proxy/Proxy.java
----------------------------------------------------------------------
diff --cc proxy/src/main/java/org/apache/accumulo/proxy/Proxy.java
index 5fa64e4,3368d20..ca39786
--- a/proxy/src/main/java/org/apache/accumulo/proxy/Proxy.java
+++ b/proxy/src/main/java/org/apache/accumulo/proxy/Proxy.java
@@@ -23,27 -23,13 +23,26 @@@ import java.io.InputStream
  import java.util.Properties;
  
  import org.apache.accumulo.core.cli.Help;
 +import org.apache.accumulo.core.client.ClientConfiguration;
 +import org.apache.accumulo.core.client.ClientConfiguration.ClientProperty;
 +import org.apache.accumulo.core.client.impl.ClientContext;
 +import org.apache.accumulo.core.client.security.tokens.KerberosToken;
  import org.apache.accumulo.core.conf.AccumuloConfiguration;
 +import org.apache.accumulo.core.conf.Property;
 +import org.apache.accumulo.core.rpc.SslConnectionParams;
  import org.apache.accumulo.minicluster.MiniAccumuloCluster;
  import org.apache.accumulo.proxy.thrift.AccumuloProxy;
 -import org.apache.accumulo.server.util.RpcWrapper;
 -import org.apache.log4j.Logger;
 -import org.apache.thrift.TBaseProcessor;
 +import org.apache.accumulo.server.metrics.MetricsFactory;
 +import org.apache.accumulo.server.rpc.RpcWrapper;
 +import org.apache.accumulo.server.rpc.SaslServerConnectionParams;
 +import org.apache.accumulo.server.rpc.ServerAddress;
 +import org.apache.accumulo.server.rpc.TServerUtils;
 +import org.apache.accumulo.server.rpc.ThriftServerType;
 +import org.apache.accumulo.server.rpc.TimedProcessor;
 +import org.apache.accumulo.server.rpc.UGIAssumingProcessor;
 +import org.apache.accumulo.start.spi.KeywordExecutable;
 +import org.apache.commons.lang.StringUtils;
 +import org.apache.hadoop.security.UserGroupInformation;
- import org.apache.thrift.TBaseProcessor;
  import org.apache.thrift.TProcessor;
  import org.apache.thrift.protocol.TCompactProtocol;
  import org.apache.thrift.protocol.TProtocolFactory;

http://git-wip-us.apache.org/repos/asf/accumulo/blob/e35e1898/server/base/src/test/java/org/apache/accumulo/server/rpc/RpcWrapperTest.java
----------------------------------------------------------------------
diff --cc server/base/src/test/java/org/apache/accumulo/server/rpc/RpcWrapperTest.java
index fac9087,0000000..e4e9402
mode 100644,000000..100644
--- a/server/base/src/test/java/org/apache/accumulo/server/rpc/RpcWrapperTest.java
+++ b/server/base/src/test/java/org/apache/accumulo/server/rpc/RpcWrapperTest.java
@@@ -1,289 -1,0 +1,304 @@@
 +/*
 + * Licensed to the Apache Software Foundation (ASF) under one or more
 + * contributor license agreements.  See the NOTICE file distributed with
 + * this work for additional information regarding copyright ownership.
 + * The ASF licenses this file to you under the Apache License, Version 2.0
 + * (the "License"); you may not use this file except in compliance with
 + * the License.  You may obtain a copy of the License at
 + *
 + * http://www.apache.org/licenses/LICENSE-2.0
 + *
 + * Unless required by applicable law or agreed to in writing, software
 + * distributed under the License is distributed on an "AS IS" BASIS,
 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 + * See the License for the specific language governing permissions and
 + * limitations under the License.
 + */
 +package org.apache.accumulo.server.rpc;
 +
 +import java.util.Collections;
 +import java.util.HashMap;
 +import java.util.Map;
 +import java.util.Set;
 +
 +import org.apache.accumulo.core.trace.wrappers.RpcServerInvocationHandler;
 +import org.apache.accumulo.server.rpc.RpcWrapper;
 +import org.apache.thrift.ProcessFunction;
 +import org.apache.thrift.TBase;
 +import org.apache.thrift.TException;
 +import org.apache.thrift.protocol.TProtocol;
 +import org.junit.Assert;
 +import org.junit.Test;
 +
 +import com.google.common.collect.Sets;
 +
 +/**
 + * Verification that RpcWrapper correctly mangles Exceptions to work around Thrift.
 + */
 +public class RpcWrapperTest {
 +
 +  private static final String RTE_MESSAGE = "RpcWrapperTest's RuntimeException Message";
 +
 +  /**
 +   * Given a method name and whether or not the method is oneway, construct a ProcessFunction.
 +   *
 +   * @param methodName
 +   *          The service method name.
 +   * @param isOneway
 +   *          Is the method oneway.
 +   * @return A ProcessFunction.
 +   */
 +  private fake_proc<FakeService> createProcessFunction(String methodName, boolean isOneway) {
 +    return new fake_proc<FakeService>(methodName, isOneway);
 +  }
 +
 +  @Test
 +  public void testSomeOnewayMethods() {
 +    @SuppressWarnings("rawtypes")
 +    Map<String,ProcessFunction<FakeService,? extends TBase>> procs = new HashMap<String,ProcessFunction<FakeService,? extends TBase>>();
 +    procs.put("foo", createProcessFunction("foo", true));
 +    procs.put("foobar", createProcessFunction("foobar", false));
 +    procs.put("bar", createProcessFunction("bar", true));
 +    procs.put("barfoo", createProcessFunction("barfoo", false));
 +
 +    Set<String> onewayMethods = RpcWrapper.getOnewayMethods(procs);
 +    Assert.assertEquals(Sets.newHashSet("foo", "bar"), onewayMethods);
 +  }
 +
 +  @Test
 +  public void testNoOnewayMethods() {
 +    @SuppressWarnings("rawtypes")
 +    Map<String,ProcessFunction<FakeService,? extends TBase>> procs = new HashMap<String,ProcessFunction<FakeService,? extends TBase>>();
 +    procs.put("foo", createProcessFunction("foo", false));
 +    procs.put("foobar", createProcessFunction("foobar", false));
 +    procs.put("bar", createProcessFunction("bar", false));
 +    procs.put("barfoo", createProcessFunction("barfoo", false));
 +
 +    Set<String> onewayMethods = RpcWrapper.getOnewayMethods(procs);
 +    Assert.assertEquals(Collections.<String> emptySet(), onewayMethods);
 +  }
 +
 +  @Test
 +  public void testAllOnewayMethods() {
 +    @SuppressWarnings("rawtypes")
 +    Map<String,ProcessFunction<FakeService,? extends TBase>> procs = new HashMap<String,ProcessFunction<FakeService,? extends TBase>>();
 +    procs.put("foo", createProcessFunction("foo", true));
 +    procs.put("foobar", createProcessFunction("foobar", true));
 +    procs.put("bar", createProcessFunction("bar", true));
 +    procs.put("barfoo", createProcessFunction("barfoo", true));
 +
 +    Set<String> onewayMethods = RpcWrapper.getOnewayMethods(procs);
 +    Assert.assertEquals(Sets.newHashSet("foo", "foobar", "bar", "barfoo"), onewayMethods);
 +  }
 +
 +  @Test
 +  public void testNoExceptionWrappingForOneway() throws Throwable {
 +    final Object[] args = new Object[0];
 +
 +    final FakeService impl = new FakeServiceImpl();
 +
 +    // "short" names throw RTEs and are oneway, while long names do not throw exceptions and are not oneway.
 +    RpcServerInvocationHandler<FakeService> handler = RpcWrapper.getInvocationHandler(impl, Sets.newHashSet("foo", "bar"));
 +
 +    // Should throw an exception, but not be wrapped because the method is oneway
 +    try {
 +      handler.invoke(impl, FakeServiceImpl.class.getMethod("foo"), args);
 +      Assert.fail("Expected an exception");
 +    } catch (RuntimeException e) {
 +      Assert.assertEquals(RTE_MESSAGE, e.getMessage());
 +    }
 +
 +    // Should not throw an exception
 +    handler.invoke(impl, FakeServiceImpl.class.getMethod("foobar"), args);
 +  }
 +
 +  @Test
 +  public void testExceptionWrappingForNonOneway() throws Throwable {
 +    final Object[] args = new Object[0];
 +
 +    final FakeService impl = new FakeServiceImpl();
 +
 +    // "short" names throw RTEs and are not oneway, while long names do not throw exceptions and are oneway.
 +    RpcServerInvocationHandler<FakeService> handler = RpcWrapper.getInvocationHandler(impl, Sets.newHashSet("foobar", "barfoo"));
 +
 +    // Should throw an exception, but not be wrapped because the method is oneway
 +    try {
 +      handler.invoke(impl, FakeServiceImpl.class.getMethod("foo"), args);
 +      Assert.fail("Expected an exception");
 +    } catch (TException e) {
 +      // The InvocationHandler should take the exception from the RTE and make it a TException
 +      Assert.assertEquals(RTE_MESSAGE, e.getMessage());
 +    }
 +
 +    // Should not throw an exception
 +    handler.invoke(impl, FakeServiceImpl.class.getMethod("foobar"), args);
 +  }
 +
 +  //
 +  // Some hacked together classes/interfaces that mimic what Thrift is doing.
 +  //
 +
 +  /**
 +   * Some fake fields for our fake arguments.
 +   */
 +  private static class fake_fields implements org.apache.thrift.TFieldIdEnum {
 +    @Override
 +    public short getThriftFieldId() {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public String getFieldName() {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public boolean equals(Object o) {
 +      throw new UnsupportedOperationException();
 +    }
++
++    @Override
++    public int hashCode() {
++      throw new UnsupportedOperationException();
++    }
 +  }
 +
 +  /**
 +   * A fake thrift service
 +   */
 +  interface FakeService {
 +    void foo();
 +
 +    String foobar();
 +
 +    int bar();
 +
 +    long barfoo();
 +  }
 +
 +  /**
 +   * An implementation of the fake thrift service. The "short" names throw RTEs, while long names do not.
 +   */
 +  public static class FakeServiceImpl implements FakeService {
 +    @Override
 +    public void foo() {
 +      throw new RuntimeException(RTE_MESSAGE);
 +    }
 +
 +    @Override
 +    public String foobar() {
 +      return "";
 +    }
 +
 +    @Override
 +    public int bar() {
 +      throw new RuntimeException(RTE_MESSAGE);
 +    }
 +
 +    @Override
 +    public long barfoo() {
 +      return 0;
 +    }
 +  };
 +
 +  /**
 +   * A fake ProcessFunction implementation for testing that allows injection of method name and oneway.
 +   */
 +  private static class fake_proc<I extends FakeService> extends org.apache.thrift.ProcessFunction<I,foo_args> {
 +    final private boolean isOneway;
 +
 +    public fake_proc(String methodName, boolean isOneway) {
 +      super(methodName);
 +      this.isOneway = isOneway;
 +    }
 +
 +    @Override
 +    protected boolean isOneway() {
 +      return isOneway;
 +    }
 +
 +    @SuppressWarnings("rawtypes")
 +    @Override
 +    public TBase getResult(I iface, foo_args args) throws TException {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public foo_args getEmptyArgsInstance() {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public boolean equals(Object o) {
 +      throw new UnsupportedOperationException();
 +    }
++
++    @Override
++    public int hashCode() {
++      throw new UnsupportedOperationException();
++    }
 +  }
 +
 +  /**
 +   * Fake arguments for our fake service.
 +   */
 +  private static class foo_args implements org.apache.thrift.TBase<foo_args,fake_fields> {
 +
 +    private static final long serialVersionUID = 1L;
 +
 +    @Override
 +    public boolean equals(Object o) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
++    public int hashCode() {
++      throw new UnsupportedOperationException();
++    }
++
++    @Override
 +    public int compareTo(foo_args o) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public void read(TProtocol iprot) throws TException {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public void write(TProtocol oprot) throws TException {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public fake_fields fieldForId(int fieldId) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public boolean isSet(fake_fields field) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public Object getFieldValue(fake_fields field) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public void setFieldValue(fake_fields field, Object value) {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public TBase<foo_args,fake_fields> deepCopy() {
 +      throw new UnsupportedOperationException();
 +    }
 +
 +    @Override
 +    public void clear() {
 +      throw new UnsupportedOperationException();
 +    }
 +  }
 +}