public void send(TCredentials credentials, String serverName, MasterClientService.Iface client)
     throws TException, ThriftSecurityException {
   TabletSplit split = new TabletSplit();
   split.oldTablet = old_extent.toThrift();
   split.newTablets = Translator.translate(extents.keySet(), Translators.KET);
   client.reportSplitExtent(Tracer.traceInfo(), credentials, serverName, split);
 }
  public static boolean getBatchFromServer(
      ClientContext context,
      Range range,
      KeyExtent extent,
      String server,
      SortedMap<Key, Value> results,
      SortedSet<Column> fetchedColumns,
      List<IterInfo> serverSideIteratorList,
      Map<String, Map<String, String>> serverSideIteratorOptions,
      int size,
      Authorizations authorizations,
      boolean retry,
      long batchTimeOut,
      String classLoaderContext)
      throws AccumuloException, AccumuloSecurityException, NotServingTabletException {
    if (server == null) throw new AccumuloException(new IOException());

    final HostAndPort parsedServer = HostAndPort.fromString(server);
    try {
      TInfo tinfo = Tracer.traceInfo();
      TabletClientService.Client client = ThriftUtil.getTServerClient(parsedServer, context);
      try {
        // not reading whole rows (or stopping on row boundries) so there is no need to enable
        // isolation below
        ScanState scanState =
            new ScanState(
                context,
                extent.getTableId(),
                authorizations,
                range,
                fetchedColumns,
                size,
                serverSideIteratorList,
                serverSideIteratorOptions,
                false,
                Constants.SCANNER_DEFAULT_READAHEAD_THRESHOLD,
                null,
                batchTimeOut,
                classLoaderContext);

        TabletType ttype = TabletType.type(extent);
        boolean waitForWrites = !serversWaitedForWrites.get(ttype).contains(server);
        InitialScan isr =
            client.startScan(
                tinfo,
                scanState.context.rpcCreds(),
                extent.toThrift(),
                scanState.range.toThrift(),
                Translator.translate(scanState.columns, Translators.CT),
                scanState.size,
                scanState.serverSideIteratorList,
                scanState.serverSideIteratorOptions,
                scanState.authorizations.getAuthorizationsBB(),
                waitForWrites,
                scanState.isolated,
                scanState.readaheadThreshold,
                null,
                scanState.batchTimeOut,
                classLoaderContext);
        if (waitForWrites) serversWaitedForWrites.get(ttype).add(server);

        Key.decompress(isr.result.results);

        for (TKeyValue kv : isr.result.results) results.put(new Key(kv.key), new Value(kv.value));

        client.closeScan(tinfo, isr.scanID);

        return isr.result.more;
      } finally {
        ThriftUtil.returnClient(client);
      }
    } catch (TApplicationException tae) {
      throw new AccumuloServerException(server, tae);
    } catch (TooManyFilesException e) {
      log.debug("Tablet ({}) has too many files {} : {}", extent, server, e.getMessage());
    } catch (ThriftSecurityException e) {
      log.warn("Security Violation in scan request to {}: {}", server, e.getMessage());
      throw new AccumuloSecurityException(e.user, e.code, e);
    } catch (TException e) {
      log.debug("Error getting transport to {}: {}", server, e.getMessage());
    }

    throw new AccumuloException("getBatchFromServer: failed");
  }
  private static List<KeyValue> scan(TabletLocation loc, ScanState scanState, ClientContext context)
      throws AccumuloSecurityException, NotServingTabletException, TException,
          NoSuchScanIDException, TooManyFilesException, TSampleNotPresentException {
    if (scanState.finished) return null;

    OpTimer timer = null;

    final TInfo tinfo = Tracer.traceInfo();
    final HostAndPort parsedLocation = HostAndPort.fromString(loc.tablet_location);
    TabletClientService.Client client = ThriftUtil.getTServerClient(parsedLocation, context);

    String old = Thread.currentThread().getName();
    try {
      ScanResult sr;

      if (scanState.prevLoc != null && !scanState.prevLoc.equals(loc)) scanState.scanID = null;

      scanState.prevLoc = loc;

      if (scanState.scanID == null) {
        String msg =
            "Starting scan tserver="
                + loc.tablet_location
                + " tablet="
                + loc.tablet_extent
                + " range="
                + scanState.range
                + " ssil="
                + scanState.serverSideIteratorList
                + " ssio="
                + scanState.serverSideIteratorOptions;
        Thread.currentThread().setName(msg);

        if (log.isTraceEnabled()) {
          log.trace("tid={} {}", Thread.currentThread().getId(), msg);
          timer = new OpTimer().start();
        }

        TabletType ttype = TabletType.type(loc.tablet_extent);
        boolean waitForWrites = !serversWaitedForWrites.get(ttype).contains(loc.tablet_location);

        InitialScan is =
            client.startScan(
                tinfo,
                scanState.context.rpcCreds(),
                loc.tablet_extent.toThrift(),
                scanState.range.toThrift(),
                Translator.translate(scanState.columns, Translators.CT),
                scanState.size,
                scanState.serverSideIteratorList,
                scanState.serverSideIteratorOptions,
                scanState.authorizations.getAuthorizationsBB(),
                waitForWrites,
                scanState.isolated,
                scanState.readaheadThreshold,
                SamplerConfigurationImpl.toThrift(scanState.samplerConfig),
                scanState.batchTimeOut,
                scanState.classLoaderContext);
        if (waitForWrites) serversWaitedForWrites.get(ttype).add(loc.tablet_location);

        sr = is.result;

        if (sr.more) scanState.scanID = is.scanID;
        else client.closeScan(tinfo, is.scanID);

      } else {
        // log.debug("Calling continue scan : "+scanState.range+" loc = "+loc);
        String msg =
            "Continuing scan tserver=" + loc.tablet_location + " scanid=" + scanState.scanID;
        Thread.currentThread().setName(msg);

        if (log.isTraceEnabled()) {
          log.trace("tid={} {}", Thread.currentThread().getId(), msg);
          timer = new OpTimer().start();
        }

        sr = client.continueScan(tinfo, scanState.scanID);
        if (!sr.more) {
          client.closeScan(tinfo, scanState.scanID);
          scanState.scanID = null;
        }
      }

      if (!sr.more) {
        // log.debug("No more : tab end row = "+loc.tablet_extent.getEndRow()+" range =
        // "+scanState.range);
        if (loc.tablet_extent.getEndRow() == null) {
          scanState.finished = true;

          if (timer != null) {
            timer.stop();
            log.trace(
                "tid={} Completely finished scan in {} #results={}",
                Thread.currentThread().getId(),
                String.format("%.3f secs", timer.scale(TimeUnit.SECONDS)),
                sr.results.size());
          }

        } else if (scanState.range.getEndKey() == null
            || !scanState.range.afterEndKey(
                new Key(loc.tablet_extent.getEndRow()).followingKey(PartialKey.ROW))) {
          scanState.startRow = loc.tablet_extent.getEndRow();
          scanState.skipStartRow = true;

          if (timer != null) {
            timer.stop();
            log.trace(
                "tid={} Finished scanning tablet in {} #results={}",
                Thread.currentThread().getId(),
                String.format("%.3f secs", timer.scale(TimeUnit.SECONDS)),
                sr.results.size());
          }
        } else {
          scanState.finished = true;
          if (timer != null) {
            timer.stop();
            log.trace(
                "tid={} Completely finished in {} #results={}",
                Thread.currentThread().getId(),
                String.format("%.3f secs", timer.scale(TimeUnit.SECONDS)),
                sr.results.size());
          }
        }
      } else {
        if (timer != null) {
          timer.stop();
          log.trace(
              "tid={} Finished scan in {} #results={} scanid={}",
              Thread.currentThread().getId(),
              String.format("%.3f secs", timer.scale(TimeUnit.SECONDS)),
              sr.results.size(),
              scanState.scanID);
        }
      }

      Key.decompress(sr.results);

      if (sr.results.size() > 0 && !scanState.finished)
        scanState.range =
            new Range(
                new Key(sr.results.get(sr.results.size() - 1).key),
                false,
                scanState.range.getEndKey(),
                scanState.range.isEndKeyInclusive());

      List<KeyValue> results = new ArrayList<KeyValue>(sr.results.size());
      for (TKeyValue tkv : sr.results) results.add(new KeyValue(new Key(tkv.key), tkv.value));

      return results;

    } catch (ThriftSecurityException e) {
      throw new AccumuloSecurityException(e.user, e.code, e);
    } finally {
      ThriftUtil.returnClient(client);
      Thread.currentThread().setName(old);
    }
  }