import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Gets the a sorted Map<UUID, Integer> UuidIntMap from a DataCube<UuidIntMap>.
 */
private <O> Map<UUID, Integer> getMapFromCube(DataCubeIo<UuidIntMap> dataCubeIo, DataCube<UuidIntMap> dataCube,
  Dimension<?> dimension, O coordinate) {
  try {
    Optional<UuidIntMap> o = null;
    if (coordinate != null) {
      o = dataCubeIo.get(new ReadBuilder(dataCube).at(dimension, coordinate));
    }
    if (o != null && o.isPresent()) {
      return sortDescending(o.get().getCounts());
    } else {
      return sortDescending(UuidIntMap.EMPTY_MAP.getCounts());
    }
  } catch (Exception e) {
    e.printStackTrace();
    LOG.error("Unable to read from the cube", e);
    throw new ServiceUnavailableException("Unable to read from the taxon occurrence dataset cube", e);
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Override
public Set<Integer> findKeysByScope(String scope) {
  Set<Integer> keys = Sets.newHashSet();
  // note HTableStore isn't capable of ad hoc scans
  try (Table table = connection.getTable(lookupTableName)) {
    Scan scan = new Scan();
    scan.setCacheBlocks(false);
    scan.setCaching(HBASE_CLIENT_CACHING);
    scan.setFilter(new PrefixFilter(Bytes.toBytes(scope)));
    ResultScanner results = table.getScanner(scan);
    for (Result result : results) {
      byte[] rawKey = result.getValue(Columns.CF, Bytes.toBytes(Columns.LOOKUP_KEY_COLUMN));
      if (rawKey != null) {
        keys.add(Bytes.toInt(rawKey));
      }
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not read from HBase", e);
  }
  return keys;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Override
public void deleteKeyByUniques(Set<String> uniqueStrings, String scope) {
  checkNotNull(uniqueStrings, "uniqueStrings can't be null");
  checkNotNull(scope, "scope can't be null");

  // craft a delete for every uniqueString
  Set<String> lookupKeys = keyBuilder.buildKeys(uniqueStrings, scope);
  List<Delete> keysToDelete = Lists.newArrayListWithCapacity(lookupKeys.size());
  for (String lookupKey : lookupKeys) {
    keysToDelete.add(new Delete(Bytes.toBytes(lookupKey)));
  }
  try (Table lookupTable = connection.getTable(lookupTableName)) {
    if (!keysToDelete.isEmpty()) {
      lookupTable.delete(keysToDelete);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException("Failure accessing HBase", e);
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
public long incrementColumnValue(T key, String columnName, long value) {
  checkNotNull(key, KEY_CANT_BE_NULL_MSG);
  checkNotNull(columnName, "columnName can't be null");
  checkNotNull(value, "value can't be null");

  long result = 0;
  try (Table table = connection.getTable(tableName)) {
    byte[] byteKey = convertKey(key);
    if (byteKey != null) {
      result = table.incrementColumnValue(byteKey, cfBytes, Bytes.toBytes(columnName), value);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException(HBASE_READ_ERROR_MSG, e);
  }

  return result;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Returns an HBase Result object matching the given key and column name.
 *
 * @param key the primary key of the requested row
 * @param columnName the column value to return
 * @return HBase Result
 *
 * @throws ServiceUnavailableException if there are errors when communicating with HBase
 */
public Result getRow(T key, String columnName) {
  checkNotNull(key, KEY_CANT_BE_NULL_MSG);
  checkNotNull(columnName, "columnName can't be null");

  Result row = null;
  try (Table table = connection.getTable(tableName)) {
    byte[] byteKey = convertKey(key);
    if (byteKey != null) {
      Get get = new Get(byteKey);
      get.addColumn(cfBytes, Bytes.toBytes(columnName));
      row = table.get(get);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException(HBASE_READ_ERROR_MSG, e);
  }

  return row;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Do an HBase checkAndPut - a put that will only be attempted if the checkColumn contains the expected checkValue.
 *
 * @param key the primary key of the row
 * @param putColumn the column where the new value will be stored
 * @param putValue the new value to put
 * @param checkColumn the column to check
 * @param checkValue the expected value of the checkColumn
 * @param ts the timestamp to write on the put (if null, the current timestamp will be used)
 * @return true if condition was met and put was successful, false otherwise
 *
 * @throws ServiceUnavailableException if there are errors when communicating with HBase
 */
public boolean checkAndPut(T key, String putColumn, byte[] putValue, String checkColumn, @Nullable byte[] checkValue,
                           @Nullable Long ts) {
  checkNotNull(key, KEY_CANT_BE_NULL_MSG);
  checkNotNull(putColumn, "putColumn can't be null");
  checkNotNull(putValue, "putValue can't be null");
  checkNotNull(checkColumn, "checkColumn can't be null");

  boolean success = false;
  try (Table table = connection.getTable(tableName)) {
    byte[] byteKey = convertKey(key);
    if (byteKey != null) {
      Put put = new Put(byteKey);
      if (ts != null && ts > 0) {
        put.addColumn(cfBytes, Bytes.toBytes(putColumn), ts, putValue);
      } else {
        put.addColumn(cfBytes, Bytes.toBytes(putColumn), putValue);
      }
      success = table.checkAndPut(byteKey, cfBytes, Bytes.toBytes(checkColumn), checkValue, put);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException(HBASE_READ_ERROR_MSG, e);
  }

  return success;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Note that the returned fragment here is a String that holds the actual xml or json snippet for this occurrence,
 * and not the Fragment object that is used elsewhere.
 *
 * @param key that identifies an occurrence
 * @return a String holding the original xml or json snippet for this occurrence
 */
@Override
public String getFragment(int key) {
  String fragment = null;
  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName))) {
    Get get = new Get(Bytes.toBytes(key));
    Result result = table.get(get);
    if (result == null || result.isEmpty()) {
      LOG.info("Couldn't find occurrence for id [{}], returning null", key);
      return null;
    }
    byte[] rawFragment = ExtResultReader.getBytes(result, Columns.column(GbifInternalTerm.fragment));
    if (rawFragment != null) {
      fragment = Bytes.toString(rawFragment);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not read from HBase", e);
  }
  return fragment;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Nullable
@Override
public VerbatimOccurrence getVerbatim(@Nullable Integer key) {
  if (key == null) {
    return null;
  }
  VerbatimOccurrence verb = null;
  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName)))  {
    Get get = new Get(Bytes.toBytes(key));
    Result result = table.get(get);
    if (result == null || result.isEmpty()) {
      LOG.debug("Couldn't find occurrence for key [{}], returning null", key);
      return null;
    }
    verb = OccurrenceBuilder.buildVerbatimOccurrence(result);
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not read from HBase", e);
  }

  return verb;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Override
public void delete(List<Integer> occurrenceKeys) {
  checkNotNull(occurrenceKeys, "occurrenceKeys can't be null");

  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName)))  {
    List<Delete> deletes = Lists.newArrayListWithExpectedSize(occurrenceKeys.size());
    for (Integer occurrenceKey : occurrenceKeys) {
      if (occurrenceKey != null) {
        deletes.add(new Delete(Bytes.toBytes(occurrenceKey)));
      }
    }
    LOG.debug("Deleting [{}] occurrences", occurrenceKeys.size());
    table.delete(deletes);
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not access HBase", e);
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
<T extends VerbatimOccurrence> RowUpdate buildRowUpdate(T occ) {
  checkNotNull(occ, "occurrence can't be null");
  checkNotNull(occ.getKey(), "occurrence's key can't be null");

  RowUpdate upd = new RowUpdate(occ.getKey());
  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName))) {
    if (occ instanceof Occurrence) {
      populateVerbatimPutDelete(table, upd, occ, false);
      populateInterpretedPutDelete(upd, (Occurrence) occ);
    } else {
      populateVerbatimPutDelete(table, upd, occ, true);
    }
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not access HBase", e);
  }

  return upd;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Returns true if a key was created, false otherwise.
 */
private boolean write(Fragment fragment, boolean createKey, @Nullable Set<UniqueIdentifier> uniqueIds) {
  if (createKey) {
    checkNotNull(uniqueIds, "uniqueIds can't be null if createKey is true");
  }

  boolean keyCreated = false;
  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName))) {
    if (createKey) {
      KeyLookupResult keyLookupResult = keyService.generateKey(uniqueIds);
      keyCreated = keyLookupResult.isCreated();
      fragment.setKey(keyLookupResult.getKey());
    }
    writeFields(table, fragment);
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not access HBase", e);
  }

  return keyCreated;
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Override
public void cancel(String downloadKey) {
  try {
    Download download = occurrenceDownloadService.get(downloadKey);
    if (download != null) {
      if (RUNNING_STATUSES.contains(download.getStatus())) {
        updateDownloadStatus(download, Download.Status.CANCELLED);
        client.kill(DownloadUtils.downloadToWorkflowId(downloadKey));
        LOG.info("Download {} cancelled", downloadKey);
      }
    } else {
      throw new NotFoundException(String.format("Download %s not found", downloadKey));
    }
  } catch (OozieClientException e) {
    throw new ServiceUnavailableException("Failed to cancel download " + downloadKey, e);
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Override
public String create(DownloadRequest request) {
  LOG.debug("Trying to create download from request [{}]", request);
  Preconditions.checkNotNull(request);
  try {
    if (!downloadLimitsService.isInDownloadLimits(request.getCreator())) {
      throw new WebApplicationException(Response.status(GbifResponseStatus.ENHANCE_YOUR_CALM.getStatus()).build());
    }
    String jobId = client.run(parametersBuilder.buildWorkflowParameters(request));
    LOG.debug("oozie job id is: [{}]", jobId);
    String downloadId = DownloadUtils.workflowToDownloadId(jobId);
    persistDownload(request, downloadId);
    return downloadId;
  } catch (OozieClientException e) {
    throw new ServiceUnavailableException("Failed to create download job", e);
  }

}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Test
public void testGetResult() throws ServiceUnavailableException {
  try {
    when(mockedRs.getObject("language_i")).thenReturn("en");
    assertThat(th.getResult(mockedRs, "language_i"), is(Language.ENGLISH));
  } catch (SQLException e) {
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Test
public void testGetResult() throws ServiceUnavailableException {
  try {
    when(mockedRs.getObject("country_i")).thenReturn("dk");
    assertThat(th.getResult(mockedRs, "country_i"), is(Country.DENMARK));
  } catch (SQLException e) {
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Test
public void testGetResult() throws ServiceUnavailableException {
  try {
    when(mockedRs.getObject("rid")).thenReturn(3l);
    Assert.assertEquals(UserRole.ADMIN, th.getResult(mockedRs, "rid"));
  } catch (SQLException e) {
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@Test
public void testGetNull() throws ServiceUnavailableException {
  try {
    when(mockedRs.getObject("rid")).thenReturn(null);
    Assert.assertNull(th.getResult(mockedRs, "rid"));
  } catch (SQLException e) {
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
private <T extends VerbatimOccurrence> void updateOcc(T occ) {
  checkNotNull(occ, "occurrence can't be null");
  checkNotNull(occ.getKey(), "occurrence's key can't be null");

  RowUpdate upd = buildRowUpdate(occ);

  try (Table table = connection.getTable(TableName.valueOf(occurrenceTableName))) {
    upd.execute(table);
  } catch (IOException e) {
    throw new ServiceUnavailableException("Could not access HBase", e);
  }
}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
/**
 * Serializes a predicate filter into a json string.
 */
private static String getJsonStringPredicate(Predicate predicate) {
  try {
    StringWriter writer = new StringWriter();
    JSON_MAPPER.writeValue(writer, predicate);
    writer.flush();
    return writer.toString();
  } catch (IOException e) {
    throw new ServiceUnavailableException("Failed to serialize download filter " + predicate, e);
  }

}
 

import org.gbif.api.exception.ServiceUnavailableException; //导入依赖的package包/类
@SuppressWarnings({"unchecked", "rawtypes"})
@VisibleForTesting
ReadBuilder build(MultivaluedMap<String, String> params) throws ServiceUnavailableException, IllegalArgumentException {
  ReadBuilder b = new ReadBuilder(OccurrenceCube.INSTANCE);
  for (Entry<String, List<String>> param : params.entrySet()) {
    // We only accept 1 value per parameter
    String k = param.getKey();
    String v = param.getValue().iterator().next();

    // callback is a reserved word in the API and invokes the JS callback hack
    // JQuery also inserts _ when using the callback=?
    if ("callback".equalsIgnoreCase(k) || "_".equalsIgnoreCase(k)) {
      continue;
    }

    Dimension<?> dim = PARAM_INDEX.get(k);
    Preconditions.checkArgument(dim != null, "Unknown parameter found in the request, does not map to a dimension: "
      + k);
    Class<?> type = dim.getType();

    // translate the API dimension to the internal dimension, typing the value
    // Note: The API_MAPPING might be determined at runtime, with the cube's implementing an interface allowing that
    // to be read.
    com.urbanairship.datacube.Dimension<?> internalDim = OccurrenceCube.API_MAPPING.get(dim);
    if (internalDim == null) {
      throw new ServiceUnavailableException("Unable to convert address in the cube.  No dimension exists for "
        + dim.getKey());
    } else if (String.class == type) {
      b.at(internalDim, v);

    } else if (Integer.class == type) {
      b.at(internalDim, Integer.valueOf(v));

    } else if (Float.class == type) {
      b.at(internalDim, Float.valueOf(v));

    } else if (Double.class == type) {
      b.at(internalDim, Double.valueOf(v));

    } else if (Boolean.class == type) {
      b.at(internalDim, Boolean.valueOf(v));

    } else if (UUID.class == type) {
      b.at(internalDim, UUID.fromString(v));

    } else if (Country.class.isAssignableFrom(type)) {
      b.at(internalDim, Country.fromIsoCode(v));

    } else if (Enum.class.isAssignableFrom(type)) {
      b.at(internalDim, Enum.valueOf((Class<Enum>) dim.getType(), v));

    } else {
      throw new ServiceUnavailableException("Dimension is of unknown type: " + type);
    }
  }
  return b;
}