arangodb/arangod/Indexes/IndexFactory.cpp

////////////////////////////////////////////////////////////////////////////////
/// DISCLAIMER
///
/// Copyright 2014-2016 ArangoDB GmbH, Cologne, Germany
/// Copyright 2004-2014 triAGENS GmbH, Cologne, Germany
///
/// Licensed 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.
///
/// Copyright holder is ArangoDB GmbH, Cologne, Germany
///
/// @author Michael Hackstein
////////////////////////////////////////////////////////////////////////////////

#include "IndexFactory.h"
#include "Basics/Exceptions.h"
#include "Basics/StaticStrings.h"
#include "Basics/StringUtils.h"
#include "Basics/VelocyPackHelper.h"
#include "Cluster/ServerState.h"
#include "Indexes/Index.h"
#include "RestServer/BootstrapFeature.h"

#include <velocypack/Slice.h>

namespace arangodb {

void IndexFactory::clear() {
  _factories.clear();
  _normalizers.clear();
}

Result IndexFactory::emplaceFactory(std::string const& type, IndexTypeFactory const& factory) {
  if (!factory) {
    return arangodb::Result(TRI_ERROR_BAD_PARAMETER,
                            std::string(
                                "index factory undefined during index factory "
                                "registration for index type '") +
                                type + "'");
  }

  auto* feature = arangodb::application_features::ApplicationServer::lookupFeature(
      "Bootstrap");
  auto* bootstrapFeature = dynamic_cast<BootstrapFeature*>(feature);

  // ensure new factories are not added at runtime since that would require additional locks
  if (bootstrapFeature && bootstrapFeature->isReady()) {
    return arangodb::Result(TRI_ERROR_INTERNAL,
                            std::string("index factory registration is only "
                                        "allowed during server startup"));
  }

  if (!_factories.emplace(type, factory).second) {
    return arangodb::Result(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, std::string("index factory previously registered during index factory registration for index type '") +
                                                                       type +
                                                                       "'");
  }

  return arangodb::Result();
}

Result IndexFactory::emplaceNormalizer(std::string const& type,
                                       IndexNormalizer const& normalizer) {
  if (!normalizer) {
    return arangodb::Result(TRI_ERROR_BAD_PARAMETER,
                            std::string(
                                "index normalizer undefined during index "
                                "normalizer registration for index type '") +
                                type + "'");
  }

  auto* feature = arangodb::application_features::ApplicationServer::lookupFeature(
      "Bootstrap");
  auto* bootstrapFeature = dynamic_cast<BootstrapFeature*>(feature);

  // ensure new normalizers are not added at runtime since that would require additional locks
  if (bootstrapFeature && bootstrapFeature->isReady()) {
    return arangodb::Result(TRI_ERROR_INTERNAL,
                            std::string("index normalizer registration is only "
                                        "allowed during server startup"));
  }

  if (!_normalizers.emplace(type, normalizer).second) {
    return arangodb::Result(TRI_ERROR_ARANGO_DUPLICATE_IDENTIFIER, std::string("index normalizer previously registered during index normalizer registration for index type '") +
                                                                       type +
                                                                       "'");
  }

  return arangodb::Result();
}

Result IndexFactory::enhanceIndexDefinition(velocypack::Slice const definition,
                                            velocypack::Builder& normalized,
                                            bool isCreation, bool isCoordinator) const {
  auto type = definition.get(StaticStrings::IndexType);

  if (!type.isString()) {
    return TRI_ERROR_BAD_PARAMETER;
  }

  auto typeString = type.copyString();
  auto itr = _normalizers.find(typeString);

  if (itr == _normalizers.end()) {
    return TRI_ERROR_BAD_PARAMETER;
  }

  TRI_ASSERT(ServerState::instance()->isCoordinator() == isCoordinator);
  TRI_ASSERT(normalized.isEmpty());

  try {
    velocypack::ObjectBuilder b(&normalized);
    auto idSlice = definition.get(StaticStrings::IndexId);
    uint64_t id = 0;

    if (idSlice.isNumber()) {
      id = idSlice.getNumericValue<uint64_t>();
    } else if (idSlice.isString()) {
      id = basics::StringUtils::uint64(idSlice.copyString());
    }

    if (id) {
      normalized.add(StaticStrings::IndexId,
                     arangodb::velocypack::Value(std::to_string(id)));
    }

    return itr->second(normalized, definition, isCreation);
  } catch (basics::Exception const& ex) {
    return ex.code();
  } catch (std::exception const&) {
    return TRI_ERROR_OUT_OF_MEMORY;
  } catch (...) {
    return TRI_ERROR_INTERNAL;
  }
}

std::shared_ptr<Index> IndexFactory::prepareIndexFromSlice(velocypack::Slice definition,
                                                           bool generateKey,
                                                           LogicalCollection& collection,
                                                           bool isClusterConstructor) const {
  auto id = validateSlice(definition, generateKey, isClusterConstructor);
  auto type = definition.get(StaticStrings::IndexType);

  if (!type.isString()) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                   "invalid index type definition");
  }

  auto typeString = type.copyString();
  auto itr = _factories.find(typeString);

  if (itr == _factories.end()) {
    THROW_ARANGO_EXCEPTION_MESSAGE(
        TRI_ERROR_NOT_IMPLEMENTED,
        std::string("invalid or unsupported index type '") + typeString + "'");
  }

  return itr->second(collection, definition, id, isClusterConstructor);
}

/// same for both storage engines
std::vector<std::string> IndexFactory::supportedIndexes() const {
  return std::vector<std::string>{"primary",    "edge", "hash",    "skiplist",
                                  "persistent", "geo",  "fulltext"};
}

TRI_idx_iid_t IndexFactory::validateSlice(arangodb::velocypack::Slice info,
                                          bool generateKey, bool isClusterConstructor) {
  if (!info.isObject()) {
    THROW_ARANGO_EXCEPTION(TRI_ERROR_BAD_PARAMETER);
  }

  TRI_idx_iid_t iid = 0;
  auto value = info.get(StaticStrings::IndexId);

  if (value.isString()) {
    iid = basics::StringUtils::uint64(value.copyString());
  } else if (value.isNumber()) {
    iid = basics::VelocyPackHelper::getNumericValue<TRI_idx_iid_t>(
        info, StaticStrings::IndexId.c_str(), 0);
  } else if (!generateKey) {
    // In the restore case it is forbidden to NOT have id
    THROW_ARANGO_EXCEPTION_MESSAGE(
        TRI_ERROR_INTERNAL, "cannot restore index without index identifier");
  }

  if (iid == 0 && !isClusterConstructor) {
    // Restore is not allowed to generate an id
    VPackSlice type = info.get("type");
    // dont generate ids for indexes of type "primary"
    // id 0 is expected for primary indexes
    if (!type.isString() || !type.isEqualString("primary")) {
      TRI_ASSERT(generateKey);
      iid = arangodb::Index::generateId();
    }
  }

  return iid;
}

}  // namespace arangodb