////////////////////////////////////////////////////////////////////////////////
/// 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 Dr. Frank Celler
////////////////////////////////////////////////////////////////////////////////

#include "v8-utils.h"

#include "Basics/Common.h"

#ifdef _WIN32
#include <WinSock2.h>  // must be before windows.h
#include <conio.h>
#include <fcntl.h>
#include <io.h>
#include <windef.h>
#include <windows.h>
#include "Basics/win-utils.h"
#endif

#include <errno.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unicode/umachine.h>
#include <unicode/unistr.h>
#include <unicode/unorm2.h>
#include <unicode/utypes.h>
#include <chrono>
#include <fstream>
#include <functional>
#include <iostream>
#include <memory>
#include <set>
#include <thread>
#include <type_traits>
#include <unordered_map>
#include <utility>
#include <vector>

#include "unicode/normalizer2.h"

#include "ApplicationFeatures/ApplicationServer.h"
#include "ApplicationFeatures/HttpEndpointProvider.h"
#include "ApplicationFeatures/V8SecurityFeature.h"
#include "Basics/Exceptions.h"
#include "Basics/FileResultString.h"
#include "Basics/FileUtils.h"
#include "Basics/Nonce.h"
#include "Basics/Result.h"
#include "Basics/ScopeGuard.h"
#include "Basics/StaticStrings.h"
#include "Basics/StringBuffer.h"
#include "Basics/StringUtils.h"
#include "Basics/Thread.h"
#include "Basics/Utf8Helper.h"
#include "Basics/build.h"
#include "Basics/debugging.h"
#include "Basics/error.h"
#include "Basics/files.h"
#include "Basics/memory.h"
#include "Basics/operating-system.h"
#include "Basics/process-utils.h"
#include "Basics/socket-utils.h"
#include "Basics/system-compiler.h"
#include "Basics/system-functions.h"
#include "Basics/terminal-utils.h"
#include "Basics/threads.h"
#include "Basics/tri-strings.h"
#include "Basics/tri-zip.h"
#include "Basics/voc-errors.h"
#include "Endpoint/Endpoint.h"
#include "Logger/LogLevel.h"
#include "Logger/LogMacros.h"
#include "Logger/LogTopic.h"
#include "Logger/Logger.h"
#include "Logger/LoggerStream.h"
#include "Random/UniformCharacter.h"
#include "Rest/CommonDefines.h"
#include "Rest/GeneralRequest.h"
#include "Rest/GeneralResponse.h"
#include "SimpleHttpClient/GeneralClientConnection.h"
#include "SimpleHttpClient/SimpleHttpClient.h"
#include "SimpleHttpClient/SimpleHttpResult.h"
#include "Ssl/SslInterface.h"
#include "Ssl/ssl-helper.h"
#include "V8/v8-buffer.h"
#include "V8/v8-conv.h"
#include "V8/v8-globals.h"
#include "V8/v8-vpack.h"

#ifdef TRI_HAVE_UNISTD_H
#include <unistd.h>
#endif

#include <velocypack/StringRef.h>
#include <velocypack/Validator.h>
#include <velocypack/velocypack-aliases.h>

using namespace arangodb;
using namespace arangodb::application_features;
using namespace arangodb::basics;
using namespace arangodb::httpclient;
using namespace arangodb::rest;

/// @brief Random string generators
namespace {
static UniformCharacter JSAlphaNumGenerator(
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789");
static UniformCharacter JSNumGenerator("0123456789");
static UniformCharacter JSSaltGenerator(
    "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*(){}"
    "[]:;<>,.?/|");
}  // namespace

/// @brief Converts an object to a UTF-8-encoded and normalized character array.
TRI_Utf8ValueNFC::TRI_Utf8ValueNFC(v8::Isolate* isolate, v8::Handle<v8::Value> const obj)
    : _str(nullptr), _length(0) {
  v8::String::Value str(isolate, obj);

  _str = TRI_normalize_utf16_to_NFC(*str, (size_t)str.length(), &_length);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief Destroys a normalized string object
////////////////////////////////////////////////////////////////////////////////

TRI_Utf8ValueNFC::~TRI_Utf8ValueNFC() { TRI_Free(_str); }

////////////////////////////////////////////////////////////////////////////////
/// @brief create a Javascript error object
////////////////////////////////////////////////////////////////////////////////

static void CreateErrorObject(v8::Isolate* isolate, int errorNumber,
                              std::string const& message) noexcept {
  try {
    TRI_GET_GLOBALS();
    if (errorNumber == TRI_ERROR_OUT_OF_MEMORY) {
      LOG_TOPIC("532c3", ERR, arangodb::Logger::FIXME)
        << "encountered out-of-memory error in context #" << v8g->_id;
    }

    v8::Handle<v8::String> errorMessage = TRI_V8_STD_STRING(isolate, message);

    if (errorMessage.IsEmpty()) {
      isolate->ThrowException(v8::Object::New(isolate));
      return;
    }

    v8::Handle<v8::Value> err = v8::Exception::Error(errorMessage);

    if (err.IsEmpty()) {
      isolate->ThrowException(v8::Object::New(isolate));
      return;
    }

    v8::Handle<v8::Object> errorObject =
        err->ToObject(TRI_IGETC).FromMaybe(v8::Local<v8::Object>());

    if (errorObject.IsEmpty()) {
      isolate->ThrowException(v8::Object::New(isolate));
      return;
    }

    errorObject->Set(TRI_V8_STD_STRING(isolate, StaticStrings::ErrorNum),
                     v8::Number::New(isolate, errorNumber));
    errorObject->Set(TRI_V8_STD_STRING(isolate, StaticStrings::ErrorMessage), errorMessage);

    TRI_GET_GLOBAL(ArangoErrorTempl, v8::ObjectTemplate);

    v8::Handle<v8::Object> ArangoError = ArangoErrorTempl->NewInstance();

    if (!ArangoError.IsEmpty()) {
      errorObject->SetPrototype(TRI_IGETC, ArangoError).FromMaybe(false);  // Ignore error
    }

    isolate->ThrowException(errorObject);
  } catch (...) {
    // must not throw from here, as a C++ exception must not escape the
    // C++ bindings that are called by V8. if it does, the program will crash
  }
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads/execute a file into/in the current context
////////////////////////////////////////////////////////////////////////////////

static bool LoadJavaScriptFile(v8::Isolate* isolate, char const* filename,
                               bool stripShebang, bool execute, bool useGlobalContext) {
  v8::HandleScope handleScope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + filename);
  }

  size_t length;
  char* content = TRI_SlurpFile(filename, &length);

  if (content == nullptr) {
    LOG_TOPIC("790a5", ERR, arangodb::Logger::FIXME)
        << "cannot load JavaScript file '" << filename << "': " << TRI_last_error();
    return false;
  }

  auto guard = scopeGuard([&content] { TRI_FreeString(content); });

  size_t bangOffset = 0;
  if (stripShebang) {
    if (strncmp(content, "#!", 2) == 0) {
      // shebang
      char const* endOfBang = strchr(content, '\n');
      if (endOfBang != nullptr) {
        bangOffset = size_t(endOfBang - content + 1);
        TRI_ASSERT(bangOffset <= length);
        length -= bangOffset;
      }
    }
  }

  if (useGlobalContext) {
    constexpr char const* prologue = "(function() { ";
    constexpr char const* epilogue = "/* end-of-file */ })()";

    char* contentWrapper = TRI_Concatenate3String(prologue, content + bangOffset, epilogue);

    TRI_FreeString(content);

    length += strlen(prologue) + strlen(epilogue);
    content = contentWrapper;

    // shebang already handled here
    bangOffset = 0;
  }

  if (content == nullptr) {
    LOG_TOPIC("89c6f", ERR, arangodb::Logger::FIXME)
        << "cannot load JavaScript file '" << filename
        << "': " << TRI_errno_string(TRI_ERROR_OUT_OF_MEMORY);
    return false;
  }

  v8::Handle<v8::String> name = TRI_V8_STRING(isolate, filename);
  v8::Handle<v8::String> source =
      TRI_V8_PAIR_STRING(isolate, content + bangOffset, (int)length);

  v8::TryCatch tryCatch(isolate);

  v8::ScriptOrigin scriptOrigin(name);
  v8::Handle<v8::Script> script =
      v8::Script::Compile(TRI_IGETC, source, &scriptOrigin).FromMaybe(v8::Local<v8::Script>());

  if (tryCatch.HasCaught()) {
    TRI_LogV8Exception(isolate, &tryCatch);
    return false;
  }

  // compilation failed, print errors that happened during compilation
  if (script.IsEmpty()) {
    LOG_TOPIC("6fffa", ERR, arangodb::Logger::FIXME)
        << "cannot load JavaScript file '" << filename << "': compilation failed.";
    return false;
  }

  if (execute) {
    // execute script
    v8::Handle<v8::Value> result = script->Run(TRI_IGETC).FromMaybe(
        v8::Local<v8::Value>());  // TODO: do we want a better default fail here?

    if (tryCatch.HasCaught()) {
      TRI_LogV8Exception(isolate, &tryCatch);
      return false;
    }

    if (result.IsEmpty()) {
      return false;
    }
  }

  LOG_TOPIC("fe6a4", TRACE, arangodb::Logger::FIXME)
      << "loaded JavaScript file: '" << filename << "'";
  return true;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads all files from a directory into the current context
////////////////////////////////////////////////////////////////////////////////

static bool LoadJavaScriptDirectory(v8::Isolate* isolate, char const* path, bool stripShebang,
                                    bool execute, bool useGlobalContext) {
  v8::HandleScope scope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  LOG_TOPIC("65c8d", TRACE, arangodb::Logger::FIXME)
      << "loading JavaScript directory: '" << path << "'";

  std::vector<std::string> files = TRI_FilesDirectory(path);

  bool result = true;

  for (auto const& filename : files) {
    if (!StringUtils::isSuffix(filename, ".js")) {
      continue;
    }

    v8::TryCatch tryCatch(isolate);

    std::string full = FileUtils::buildFilename(path, filename);

    if (!v8security.isAllowedToAccessPath(isolate, full, FSAccessType::READ)) {
      THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                     std::string("not allowed to read files in this path: ") + full);
    }

    bool ok = LoadJavaScriptFile(isolate, full.c_str(), stripShebang, execute, useGlobalContext);

    result = result && ok;

    if (!ok) {
      if (tryCatch.CanContinue()) {
        TRI_LogV8Exception(isolate, &tryCatch);
      } else {
        TRI_GET_GLOBALS();
        v8g->_canceled = true;
      }
    }
  }

  return result;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns the program options
////////////////////////////////////////////////////////////////////////////////

static void JS_Options(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("options()");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  auto filter = [&v8security, isolate](std::string const& name) {
    if (name.find("passwd") != std::string::npos ||
        name.find("password") != std::string::npos ||
        name.find("secret") != std::string::npos) {
      return false;
    }
    return v8security.shouldExposeStartupOption(isolate, name);
  };

  VPackBuilder builder = server.options(filter);

  auto result = TRI_VPackToV8(isolate, builder.slice());

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief decodes a base64-encoded string
///
/// @FUN{internal.base64Decode(@FA{value})}
///
/// Base64-decodes the string @FA{value}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Base64Decode(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("base64Decode(<value>)");
  }

  try {
    std::string const value = TRI_ObjectToString(isolate, args[0]);
    std::string const base64 = StringUtils::decodeBase64(value);

    TRI_V8_RETURN_STD_STRING(base64);
  } catch (...) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  TRI_ASSERT(false);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief encodes a string as base64
///
/// @FUN{internal.base64Encode(@FA{value})}
///
/// Base64-encodes the string @FA{value}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Base64Encode(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("base64Encode(<value>)");
  }

  try {
    std::string const&& value = TRI_ObjectToString(isolate, args[0]);
    std::string const&& base64 = StringUtils::encodeBase64(value);

    TRI_V8_RETURN_STD_STRING(base64);
  } catch (...) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  TRI_ASSERT(false);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief parses a Javascript snippet, but does not execute it
///
/// @FUN{internal.parse(@FA{script})}
///
/// Parses the @FA{script} code, but does not execute it.
/// Will return *true* if the code does not have a parse error, and throw
/// an exception otherwise.
////////////////////////////////////////////////////////////////////////////////

static void JS_Parse(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  if (args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("parse(<script>)");
  }

  v8::Handle<v8::Value> source = args[0];
  v8::Handle<v8::Value> filename;

  if (args.Length() > 1) {
    filename = args[1];
  } else {
    filename = TRI_V8_ASCII_STRING(isolate, "<snippet>");
  }

  if (!source->IsString()) {
    TRI_V8_THROW_TYPE_ERROR("<script> must be a string");
  }

  v8::TryCatch tryCatch(isolate);

  v8::ScriptOrigin scriptOrigin(TRI_ObjectToString(context, filename));
  v8::Handle<v8::Script> script =
      v8::Script::Compile(TRI_IGETC,
                          source->ToString(TRI_IGETC).FromMaybe(v8::Local<v8::String>()),
                          &scriptOrigin)
          .FromMaybe(v8::Handle<v8::Script>());

  // compilation failed, we have caught an exception
  if (tryCatch.HasCaught()) {
    if (tryCatch.CanContinue()) {
      v8::Local<v8::Object> exceptionObj = tryCatch.Exception().As<v8::Object>();
      v8::Handle<v8::Message> message = tryCatch.Message();
      if (!message.IsEmpty()) {
        exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "lineNumber"),
                          v8::Number::New(isolate,
                                          message->GetLineNumber(TRI_IGETC).FromMaybe(-1)));
        exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "columnNumber"),
                          v8::Number::New(isolate, message->GetStartColumn()));
      }
      exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "fileName"),
                        filename->ToString(TRI_IGETC).FromMaybe(
                            TRI_V8_ASCII_STRING(isolate, "unknown")));
      tryCatch.ReThrow();
      return;
    } else {
      TRI_GET_GLOBALS();
      v8g->_canceled = true;
      tryCatch.ReThrow();
      return;
    }
  }

  // compilation failed, we don't know why
  if (script.IsEmpty()) {
    TRI_V8_RETURN_FALSE();
  }
  TRI_V8_RETURN_TRUE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief parses a Javascript file, but does not execute it
///
/// @FUN{internal.parseFile(@FA{filename})}
///
/// Parses the file @FA{filename}, but does not execute it.
/// Will return *true* if the code does not have a parse error, and throw
/// an exception otherwise.
////////////////////////////////////////////////////////////////////////////////

static void JS_ParseFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("parseFile(<filename>)");
  }

  if (!args[0]->IsString() && !args[0]->IsStringObject()) {
    TRI_V8_THROW_EXCEPTION_USAGE("parseFile(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  size_t length;
  char* content = TRI_SlurpFile(*name, &length);

  if (content == nullptr) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), "cannot read file");
  }

  v8::TryCatch tryCatch(isolate);

  v8::ScriptOrigin scriptOrigin(TRI_ObjectToString(context, args[0]));
  v8::Handle<v8::Script> script =
      v8::Script::Compile(TRI_IGETC, TRI_V8_PAIR_STRING(isolate, content, (int)length), &scriptOrigin)
          .FromMaybe(v8::Handle<v8::Script>());

  TRI_FreeString(content);

  // compilation failed, we have caught an exception
  if (tryCatch.HasCaught()) {
    if (tryCatch.CanContinue()) {
      v8::Local<v8::Object> exceptionObj = tryCatch.Exception().As<v8::Object>();
      v8::Handle<v8::Message> message = tryCatch.Message();
      if (!message.IsEmpty()) {
        exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "lineNumber"),
                          v8::Number::New(isolate,
                                          message->GetLineNumber(TRI_IGETC).FromMaybe(-1)));
        exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "columnNumber"),
                          v8::Number::New(isolate, message->GetStartColumn()));
      }
      exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "fileName"), args[0]);
      tryCatch.ReThrow();
      return;
    } else {
      TRI_GET_GLOBALS();
      v8g->_canceled = true;
      tryCatch.ReThrow();
      return;
    }
  }

  // compilation failed, we don't know why
  if (script.IsEmpty()) {
    TRI_V8_RETURN_FALSE();
  }
  TRI_V8_RETURN_TRUE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief helper function for internal.download()
////////////////////////////////////////////////////////////////////////////////

static std::string GetEndpointFromUrl(std::string const& url) {
  char const* p = url.c_str();
  char const* e = p + url.size();
  size_t slashes = 0;

  while (p < e) {
    if (*p == '?') {
      // http(s)://example.com?foo=bar
      return url.substr(0, p - url.c_str());
    } else if (*p == '/') {
      if (++slashes == 3) {
        return url.substr(0, p - url.c_str());
      }
    }
    ++p;
  }

  return url;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief downloads data from a URL
///
/// @FUN{internal.download(@FA{url}, @FA{body}, @FA{options}, @FA{outfile})}
///
/// Downloads the data from the URL specified by @FA{url} and saves the
/// response body to @FA{outfile}. The following @FA{options} are supported:
///
/// - @LIT{method}: the HTTP method to be used. The supported HTTP methods are
///   @LIT{DELETE}, @LIT{GET}, @LIT{HEAD}, @LIT{POST}, @LIT{PUT}, @LIT{PATCH}
///
/// - @LIT{timeout}: a timeout value for the connection
///
/// - @LIT{followRedirects}: whether or not to follow redirects
///
/// - @LIT{maxRedirects}: maximum number of redirects to follow, only useful
///   if @LIT{followRedirects} is *true*.
///
/// - @LIT{returnBodyOnError}: whether or not to return / save body on HTTP
///   error
///
/// - @LIT{returnBodyAsBuffer}: whether or not to return the result body in
///   a Buffer object (default is false, body will be returned in a String)
///
/// - @LIT{headers}: an optional array of headers to be sent for the first
///   (non-redirect) request.
///
/// Up to 5 redirects will be followed. Any user-defined headers will only be
/// sent for the first request. If no timeout is given, a default timeout will
/// be used.
///
/// If @FA{outfile} is specified, the result body will be saved in a file
/// specified by @FA{outfile}. If @FA{outfile} already exists, an error will
/// be thrown.
///
/// If @FA{outfile} is not specified, the result body will be returned in the
/// @LIT{body} attribute of the result object.
///
/// `process-utils.js` depends on simple http client error messages.
///   this needs to be adjusted if this is ever changed!
////////////////////////////////////////////////////////////////////////////////

void JS_Download(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  std::string const signature = "download(<url>, <body>, <options>, <outfile>)";

  if (args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE(signature);
  }

  std::string url = TRI_ObjectToString(isolate, args[0]);
  std::vector<std::string> endpoints;

  bool isLocalUrl = false;

  if (!url.empty() && url[0] == '/') {
    // check if we are a server
    isLocalUrl = true;
    TRI_ASSERT(server.hasFeature<HttpEndpointProvider>());
    auto& feature = server.getFeature<HttpEndpointProvider>();
    endpoints = feature.httpEndpoints();

    // a relative url. now make this an absolute URL if possible
    for (auto const& endpoint : endpoints) {
      std::string fullurl = endpoint;

      // ipv4: replace 0.0.0.0 with 127.0.0.1
      auto pos = fullurl.find("//0.0.0.0");

      if (pos != std::string::npos) {
        fullurl.replace(pos, strlen("//0.0.0.0"), "//127.0.0.1");
      }

      // ipv6: replace [::] with [::1]
      else {
        pos = fullurl.find("//[::]");

        if (pos != std::string::npos) {
          // if the server does not support ipv6, the bind will still
          // succeed, but you need to connect to 127.0.0.1
          fullurl.replace(pos, strlen("//[::]"), "//127.0.0.1");
        }
      }

      url = fullurl + url;

      break;
    }
  }

  std::string lastEndpoint = GetEndpointFromUrl(url);

  std::string body;
  if (args.Length() > 1) {
    if (args[1]->IsString() || args[1]->IsStringObject()) {
      // supplied body is a string
      body = TRI_ObjectToString(isolate, args[1]);
    } else if (args[1]->IsObject() && V8Buffer::hasInstance(isolate, args[1])) {
      // supplied body is a Buffer object
      char const* data = V8Buffer::data(isolate, args[1].As<v8::Object>());
      size_t size = V8Buffer::length(isolate, args[1].As<v8::Object>());

      if (data == nullptr) {
        TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                       "invalid <body> buffer value");
      }

      body.assign(data, size);
    }
  }

  // options
  // ------------------------------------------------------------------------

  std::unordered_map<std::string, std::string> headerFields;
  double timeout = 10.0;
  bool returnBodyAsBuffer = false;
  bool followRedirects = true;
  rest::RequestType method = rest::RequestType::GET;
  bool returnBodyOnError = false;
  int maxRedirects = 5;
  uint64_t sslProtocol = TLS_V12;
  std::string jwtToken, username, password;

  if (args.Length() > 2) {
    if (!args[2]->IsObject()) {
      TRI_V8_THROW_EXCEPTION_USAGE(signature);
    }

    v8::Handle<v8::Array> options = v8::Handle<v8::Array>::Cast(args[2]);

    if (options.IsEmpty()) {
      TRI_V8_THROW_EXCEPTION_USAGE(signature);
    }

    // ssl protocol
    if (TRI_HasProperty(context, isolate, options, "sslProtocol")) {
      if (sslProtocol >= SSL_LAST) {
        // invalid protocol
        TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                       "invalid option value for sslProtocol");
      }

      sslProtocol = TRI_ObjectToUInt64(
          isolate, TRI_GetProperty(context, isolate, options, "sslProtocol"), false);
    }

    // method
    if (TRI_HasProperty(context, isolate, options, "method")) {
      std::string methodString =
          TRI_ObjectToString(isolate, TRI_GetProperty(context, isolate, options,
                                                      "method"));

      method = GeneralRequest::translateMethod(methodString);
    }

    // headers
    if (TRI_HasProperty(context, isolate, options, "headers")) {
      v8::Handle<v8::Object> v8Headers =
          options->Get(TRI_V8_ASCII_STRING(isolate, "headers")).As<v8::Object>();
      if (v8Headers->IsObject()) {
        v8::Handle<v8::Array> props = v8Headers->GetPropertyNames();

        for (uint32_t i = 0; i < props->Length(); i++) {
          v8::Handle<v8::Value> key = props->Get(i);
          headerFields[TRI_ObjectToString(isolate, key)] =
              TRI_ObjectToString(isolate, v8Headers->Get(key));
        }
      }
    }

    // timeout
    if (TRI_HasProperty(context, isolate, options, "timeout")) {
      if (!options->Get(TRI_V8_ASCII_STRING(isolate, "timeout"))->IsNumber()) {
        TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                       "invalid option value for timeout");
      }

      timeout = TRI_ObjectToDouble(isolate, TRI_GetProperty(context, isolate,
                                                            options, "timeout"));
    }

    // return body as a buffer?
    if (TRI_HasProperty(context, isolate, options, "returnBodyAsBuffer")) {
      returnBodyAsBuffer =
          TRI_ObjectToBoolean(isolate, TRI_GetProperty(context, isolate, options,
                                                       "returnBodyAsBuffer"));
    }

    // follow redirects
    if (TRI_HasProperty(context, isolate, options, "followRedirects")) {
      followRedirects =
          TRI_ObjectToBoolean(isolate, TRI_GetProperty(context, isolate, options,
                                                       "followRedirects"));
    }

    // max redirects
    if (TRI_HasProperty(context, isolate, options, "maxRedirects")) {
      if (!TRI_GetProperty(context, isolate, options, "maxRedirects")->IsNumber()) {
        TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                       "invalid option value for maxRedirects");
      }

      maxRedirects =
          (int)TRI_ObjectToInt64(isolate, TRI_GetProperty(context, isolate, options,
                                                          "maxRedirects"));
    }

    if (!body.empty() &&
        (method == rest::RequestType::GET || method == rest::RequestType::HEAD)) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(
          TRI_ERROR_BAD_PARAMETER,
          "should not provide a body value for this request method");
    }

    if (TRI_HasProperty(context, isolate, options, "returnBodyOnError")) {
      returnBodyOnError =
          TRI_ObjectToBoolean(isolate, TRI_GetProperty(context, isolate, options,
                                                       "returnBodyOnError"));
    }

    if (TRI_HasProperty(context, isolate, options, "jwt")) {
      jwtToken = TRI_ObjectToString(isolate, TRI_GetProperty(context, isolate,
                                                             options, "jwt"));
    } else if (TRI_HasProperty(context, isolate, options, "username")) {
      username = TRI_ObjectToString(isolate, TRI_GetProperty(context, isolate, options,
                                                             "username"));
      if (TRI_HasProperty(context, isolate, options, "password")) {
        password = TRI_ObjectToString(isolate, TRI_GetProperty(context, isolate, options,
                                                               "password"));
      }
    }
  }

  // outfile
  std::string outfile;
  if (args.Length() >= 4) {
    if (args[3]->IsString() || args[3]->IsStringObject()) {
      outfile = TRI_ObjectToString(isolate, args[3]);
    }

    if (outfile.empty()) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                     "invalid value provided for outfile");
    }

    if (!v8security.isAllowedToAccessPath(isolate, outfile, FSAccessType::WRITE)) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(
          TRI_ERROR_FORBIDDEN, std::string("not allowed to modify files in this path: ") + outfile);
    }

    if (TRI_ExistsFile(outfile.c_str())) {
      TRI_V8_THROW_EXCEPTION(TRI_ERROR_CANNOT_OVERWRITE_FILE);
    }
  }

  int numRedirects = 0;

  while (numRedirects < maxRedirects) {
    std::string endpoint;
    std::string relative;

    if (url.substr(0, 7) == "http://") {
      endpoint = GetEndpointFromUrl(url).substr(7);
      relative = url.substr(7 + endpoint.length());

      if (relative.empty() || relative[0] != '/') {
        relative = "/" + relative;
      }
      if (endpoint.find(':') == std::string::npos) {
        endpoint.append(":80");
      }
      endpoint = "tcp://" + endpoint;
    } else if (url.substr(0, 8) == "https://") {
      endpoint = GetEndpointFromUrl(url).substr(8);
      relative = url.substr(8 + endpoint.length());

      if (relative.empty() || relative[0] != '/') {
        relative = "/" + relative;
      }
      if (endpoint.find(':') == std::string::npos) {
        endpoint.append(":443");
      }
      endpoint = "ssl://" + endpoint;
    } else if (url.substr(0, 6) == "srv://") {
      size_t found = url.find('/', 6);

      relative = "/";
      if (found != std::string::npos) {
        relative.append(url.substr(found + 1));
        endpoint = url.substr(6, found - 6);
      } else {
        endpoint = url.substr(6);
      }
      endpoint = "srv://" + endpoint;
    } else if (url.substr(0, 7) == "unix://") {
      // Can only have arrived here if endpoints is non empty
      if (endpoints.empty()) {
        TRI_V8_THROW_SYNTAX_ERROR("unsupported URL specified");
      }
      endpoint = endpoints.front();
      relative = url.substr(endpoint.size());
    } else if (!url.empty() && url[0] == '/') {
      size_t found;
      // relative URL. prefix it with last endpoint
      relative = url;
      url = lastEndpoint + url;
      endpoint = lastEndpoint;
      if (endpoint.substr(0, 5) == "http:") {
        endpoint = endpoint.substr(5);
        found = endpoint.find(":");
        if (found == std::string::npos) {
          endpoint = endpoint + ":80";
        }
        endpoint = "tcp:" + endpoint;
      } else if (endpoint.substr(0, 6) == "https:") {
        endpoint = endpoint.substr(6);
        found = endpoint.find(":");
        if (found == std::string::npos) {
          endpoint = endpoint + ":443";
        }
        endpoint = "ssl:" + endpoint;
      }
    } else {
      TRI_V8_THROW_SYNTAX_ERROR("unsupported URL specified");
    }

    LOG_TOPIC("d6bdb", TRACE, arangodb::Logger::FIXME)
        << "downloading file. endpoint: " << endpoint << ", relative URL: " << url;

    if (!isLocalUrl && !v8security.isAllowedToConnectToEndpoint(isolate, endpoint)) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                     "not allowed to connect to this endpoint");
    }

    std::unique_ptr<Endpoint> ep(Endpoint::clientFactory(endpoint));

    if (ep == nullptr) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                     std::string("invalid URL ") + url);
    }

    std::unique_ptr<GeneralClientConnection> connection(
        GeneralClientConnection::factory(ep.get(), timeout, timeout, 3, sslProtocol));

    if (connection == nullptr) {
      TRI_V8_THROW_EXCEPTION_MEMORY();
    }

    SimpleHttpClientParams params(timeout, false);
    params.setSupportDeflate(false);
    // security by obscurity won't work. Github requires a useragent nowadays.
    params.setExposeArangoDB(true);
    if (!jwtToken.empty()) {
      params.setJwt(jwtToken);
    } else if (!username.empty()) {
      params.setUserNamePassword("/", username, password);
    }
    SimpleHttpClient client(connection.get(), params);

    v8::Handle<v8::Object> result = v8::Object::New(isolate);

    if (numRedirects > 0) {
      // do not send extra headers now
      headerFields.clear();
    }

    // send the actual request
    std::unique_ptr<SimpleHttpResult> response(
        client.request(method, relative, (body.size() > 0 ? body.c_str() : ""),
                       body.size(), headerFields));

    int returnCode = 500;  // set a default
    std::string returnMessage = "";

    if (response == nullptr || !response->isComplete()) {
      // save error message
      returnMessage = client.getErrorMessage();
      returnCode = 500;

      if (response != nullptr && response->getHttpReturnCode() > 0) {
        returnCode = response->getHttpReturnCode();
      }
    } else {
      TRI_ASSERT(response != nullptr);

      returnMessage = response->getHttpReturnMessage();
      returnCode = response->getHttpReturnCode();

      // follow redirects?
      if (followRedirects && (returnCode == 301 || returnCode == 302 || returnCode == 307)) {
        bool found;
        url = response->getHeaderField(StaticStrings::Location, found);

        if (!found) {
          TRI_V8_THROW_EXCEPTION_INTERNAL("caught invalid redirect URL");
        }

        numRedirects++;

        isLocalUrl = false;
        if (!url.empty() && url[0] == '/') {
          isLocalUrl = true;
        }
        if (url.substr(0, 5) == "http:" || url.substr(0, 6) == "https:") {
          lastEndpoint = GetEndpointFromUrl(url);
        }
        continue;
      }

      // process response headers
      auto const& responseHeaders = response->getHeaderFields();

      v8::Handle<v8::Object> headers = v8::Object::New(isolate);

      for (auto const& it : responseHeaders) {
        headers->Set(TRI_V8_STD_STRING(isolate, it.first),
                     TRI_V8_STD_STRING(isolate, it.second));
      }

      result->Set(TRI_V8_ASCII_STRING(isolate, "headers"), headers);

      if (returnBodyOnError || (returnCode >= 200 && returnCode <= 299)) {
        try {
          std::string json;
          basics::StringBuffer const& sb = response->getBody();
          arangodb::velocypack::StringRef body(sb.c_str(), sb.length());

          bool found = false;
          std::string content =
              response->getHeaderField(StaticStrings::ContentTypeHeader, found);
          if (found && content.find(StaticStrings::MimeTypeVPack) != std::string::npos) {
            VPackOptions validationOptions = VPackOptions::Defaults;  // intentional copy
            validationOptions.validateUtf8Strings = true;
            validationOptions.checkAttributeUniqueness = true;
            validationOptions.disallowExternals = true;
            validationOptions.disallowCustom = true;
            velocypack::Validator validator(&validationOptions);
            validator.validate(sb.data(), sb.length());  // throws on error
            json.assign(VPackSlice(reinterpret_cast<uint8_t const*>(sb.data())).toJson());
            body = arangodb::velocypack::StringRef(json);
          }

          if (outfile.size() > 0) {
            // save outfile
            FileUtils::spit(outfile, body.data(), body.length());
          } else {
            // set "body" attribute in result
            if (returnBodyAsBuffer) {
              V8Buffer* buffer = V8Buffer::New(isolate, body.data(), body.length());
              v8::Local<v8::Object> bufferObject =
                  v8::Local<v8::Object>::New(isolate, buffer->_handle);
              result->Set(TRI_V8_ASCII_STRING(isolate, "body"), bufferObject);
            } else {
              result->Set(TRI_V8_ASCII_STRING(isolate, "body"),
                          TRI_V8_STD_STRING(isolate, sb));
            }
          }

        } catch (...) {
        }
      }
    }

    result->Set(TRI_V8_ASCII_STRING(isolate, "code"), v8::Number::New(isolate, returnCode));
    result->Set(TRI_V8_ASCII_STRING(isolate, "message"),
                TRI_V8_STD_STRING(isolate, returnMessage));

    TRI_V8_RETURN(result);
  }

  TRI_V8_THROW_EXCEPTION_INTERNAL("too many redirects");
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes a script
///
/// @FUN{internal.execute(@FA{script}, @FA{sandbox}, *filename*)}
///
/// Executes the @FA{script} with the @FA{sandbox} as context. Global variables
/// assigned inside the @FA{script}, will be visible in the @FA{sandbox} object
/// after execution. The *filename* is used for displaying error
/// messages.
///
/// If @FA{sandbox} is undefined, then @FN{execute} uses the current context.
////////////////////////////////////////////////////////////////////////////////

static void JS_Execute(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 3) {
    TRI_V8_THROW_EXCEPTION_USAGE("execute(<script>, <sandbox>, <filename>)");
  }

  v8::Handle<v8::Value> source = args[0];
  v8::Handle<v8::Value> sandboxValue = args[1];
  v8::Handle<v8::Value> filename = args[2];

  if (!source->IsString()) {
    TRI_V8_THROW_TYPE_ERROR("<script> must be a string");
  }

  bool useSandbox = sandboxValue->IsObject();
  v8::Handle<v8::Object> sandbox;
  v8::Handle<v8::Context> context;

  if (useSandbox) {
    sandbox = sandboxValue->ToObject(TRI_IGETC).FromMaybe(v8::Local<v8::Object>());

    // create new context
    context = v8::Context::New(isolate);
    context->Enter();

    // copy sandbox into context
    v8::Handle<v8::Array> keys = sandbox->GetPropertyNames();

    for (uint32_t i = 0; i < keys->Length(); i++) {
      v8::Handle<v8::String> key =
          TRI_ObjectToString(context, keys->Get(v8::Integer::New(isolate, i)));
      v8::Handle<v8::Value> value = sandbox->Get(key);

      if (Logger::logLevel() == arangodb::LogLevel::TRACE) {
        TRI_Utf8ValueNFC keyName(isolate, key);

        if (*keyName != nullptr) {
          LOG_TOPIC("1a894", TRACE, arangodb::Logger::FIXME)
              << "copying key '" << *keyName << "' from sandbox to context";
        }
      }

      if (value == sandbox) {
        value = context->Global();
      }

      context->Global()->Set(key, value);
    }
  }

  // execute script inside the context
  v8::Handle<v8::Script> script;
  v8::Handle<v8::Value> result;

  {
    v8::TryCatch tryCatch(isolate);

    v8::ScriptOrigin scriptOrigin(TRI_ObjectToString(context, filename));
    script = v8::Script::Compile(TRI_IGETC, TRI_ObjectToString(context, source), &scriptOrigin)
                 .FromMaybe(v8::Local<v8::Script>());

    // compilation failed, print errors that happened during compilation
    if (script.IsEmpty()) {
      if (useSandbox) {
        context->DetachGlobal();
        context->Exit();
      }

      if (tryCatch.CanContinue()) {
        v8::Local<v8::Object> exceptionObj = tryCatch.Exception().As<v8::Object>();
        v8::Handle<v8::Message> message = tryCatch.Message();
        if (!message.IsEmpty()) {
          exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "lineNumber"),
                            v8::Number::New(isolate,
                                            message->GetLineNumber(TRI_IGETC).FromMaybe(-1)));
          exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "columnNumber"),
                            v8::Number::New(isolate,
                                            message->GetStartColumn(TRI_IGETC).FromMaybe(-1)));
        }
        exceptionObj->Set(TRI_V8_ASCII_STRING(isolate, "fileName"),
                          TRI_ObjectToString(context, filename));
        tryCatch.ReThrow();
        return;
      } else {
        TRI_GET_GLOBALS();
        v8g->_canceled = true;
        tryCatch.ReThrow();
        return;
      }
    }

    // compilation succeeded, run the script
    result = script->Run(TRI_IGETC).FromMaybe(v8::Local<v8::Value>());

    if (result.IsEmpty()) {
      if (useSandbox) {
        context->DetachGlobal();
        context->Exit();
      }

      if (tryCatch.CanContinue()) {
        TRI_V8_LOG_THROW_EXCEPTION(tryCatch);
      } else {
        tryCatch.ReThrow();
        TRI_GET_GLOBALS();
        v8g->_canceled = true;
        TRI_V8_RETURN_UNDEFINED();
      }
    }
  }

  // copy result back into the sandbox
  if (useSandbox) {
    v8::Handle<v8::Array> keys = context->Global()->GetPropertyNames();

    for (uint32_t i = 0; i < keys->Length(); i++) {
      v8::Handle<v8::String> key =
          TRI_ObjectToString(context, keys->Get(v8::Integer::New(isolate, i)));
      v8::Handle<v8::Value> value = context->Global()->Get(key);

      if (Logger::logLevel() == arangodb::LogLevel::TRACE) {
        TRI_Utf8ValueNFC keyName(isolate, key);

        if (*keyName != nullptr) {
          LOG_TOPIC("a9a45", TRACE, arangodb::Logger::FIXME)
              << "copying key '" << *keyName << "' from context to sandbox";
        }
      }

      if (value == context->Global()) {
        value = sandbox;
      }

      sandbox->Set(key, value);
    }

    context->DetachGlobal();
    context->Exit();
  }

  if (useSandbox) {
    TRI_V8_RETURN_TRUE();
  }
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Exists
////////////////////////////////////////////////////////////////////////////////

static void JS_Exists(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("exists(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  if (TRI_ExistsFile(*name)) {
    TRI_V8_RETURN_TRUE();
  } else {
    TRI_V8_RETURN_FALSE();
  }
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Chmod
////////////////////////////////////////////////////////////////////////////////

static void JS_ChMod(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("chmod(<path>, <mode>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  std::string const modeStr = TRI_ObjectToString(isolate, args[1]);
  size_t const length = modeStr.length();

  if (length == 0 || length > 5) {
    TRI_V8_THROW_TYPE_ERROR(
        "<mode> must be a string with up to 4 octal digits in it plus a "
        "leading zero.");
  }

  long mode = 0;
  for (uint32_t i = 0; i < length; ++i) {
    if (modeStr[i] < '0' || modeStr[i] > '9') {
      TRI_V8_THROW_TYPE_ERROR(
          "<mode> must be a string with up to 4 octal digits in it plus a "
          "leading zero.");
    }
    char buf[2];
    buf[0] = modeStr[i];
    buf[1] = '\0';
    uint8_t digit = (uint8_t)atoi(buf);
    if (digit >= 8) {
      TRI_V8_THROW_TYPE_ERROR(
          "<mode> must be a string with up to 4 octal digits in it plus a "
          "leading zero.");
    }
    mode = mode | digit << ((length - i - 1) * 3);
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  std::string err;
  int rc = TRI_ChMod(*name, mode, err);

  if (rc != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(rc, err);
  }

  TRI_V8_RETURN_TRUE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Size
////////////////////////////////////////////////////////////////////////////////

static void JS_SizeFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("size(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  if (!TRI_ExistsFile(*name) || TRI_IsDirectory(*name)) {
    TRI_V8_THROW_EXCEPTION(TRI_ERROR_FILE_NOT_FOUND);
  }

  int64_t size = TRI_SizeFile(*name);

  if (size < 0) {
    TRI_V8_THROW_EXCEPTION(TRI_ERROR_FILE_NOT_FOUND);
  }

  TRI_V8_RETURN(v8::Number::New(isolate, (double)size));
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads in a line from stdin
////////////////////////////////////////////////////////////////////////////////

static void JS_Getline(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

#ifdef _WIN32
  std::wstring wline;
  _setmode(_fileno(stdin), _O_U16TEXT);
  std::getline(std::wcin, wline);

  TRI_V8_RETURN_STD_WSTRING(wline);
#else
  std::string line;
  getline(std::cin, line);

  TRI_V8_RETURN_STD_STRING(line);
#endif
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_GetTempPath
////////////////////////////////////////////////////////////////////////////////

static void JS_GetTempPath(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("getTempPath()");
  }

  std::string path = TRI_GetTempPath();
  v8::Handle<v8::Value> result = TRI_V8_STD_STRING(isolate, path);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, path, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + path);
  }

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_GetTempFile
////////////////////////////////////////////////////////////////////////////////

static void JS_GetTempFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() > 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("getTempFile(<directory>, <createFile>)");
  }

  char const* p = nullptr;
  std::string path;
  if (args.Length() > 0) {
    path = TRI_ObjectToString(isolate, args[0]);
    p = path.c_str();
  }

  bool create = false;
  if (args.Length() > 1) {
    create = TRI_ObjectToBoolean(isolate, args[1]);
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  std::string dir = FileUtils::buildFilename(TRI_GetTempPath(),path,"");

  if (create) {
    if (!v8security.isAllowedToAccessPath(isolate, dir, FSAccessType::WRITE)) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                     std::string("not allowed to read files in this path: ") + dir);
    }
  } else {
    if (!v8security.isAllowedToAccessPath(isolate, dir, FSAccessType::READ)) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                     std::string("not allowed to read files in this path: ") + dir);
    }
  }


  std::string result;
  long systemError;
  std::string errorMessage;
  if (TRI_GetTempName(p, result, create, systemError, errorMessage) != TRI_ERROR_NO_ERROR) {
    errorMessage = std::string("could not create temp file: ") + errorMessage;
    TRI_V8_THROW_EXCEPTION_INTERNAL(errorMessage);
  }

  // return result
  TRI_V8_RETURN_STD_STRING(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_IsDirectory
////////////////////////////////////////////////////////////////////////////////

static void JS_IsDirectory(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("isDirectory(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  // return result
  if (TRI_IsDirectory(*name)) {
    TRI_V8_RETURN_TRUE();
  } else {
    TRI_V8_RETURN_FALSE();
  }
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_IsFile
////////////////////////////////////////////////////////////////////////////////

static void JS_IsFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("isFile(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  // return result
  if (TRI_ExistsFile(*name) && !TRI_IsDirectory(*name)) {
    TRI_V8_RETURN_TRUE();
  } else {
    TRI_V8_RETURN_FALSE();
  }
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_MakeAbsolute
////////////////////////////////////////////////////////////////////////////////

static void JS_MakeAbsolute(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("makeAbsolute(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  FileResultString cwd = FileUtils::currentDirectory();

  if (!cwd.ok()) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(cwd.sysErrorNumber(),
                                   "cannot get current working directory: " +
                                       cwd.errorMessage());
  }

  std::string abs = TRI_GetAbsolutePath(std::string(*name, name.length()), cwd.result());

  v8::Handle<v8::String> res;

  if (!abs.empty()) {
    res = TRI_V8_STD_STRING(isolate, abs);
  } else {
    res = TRI_V8_STD_STRING(isolate, cwd.result());
  }

  // return result
  TRI_V8_RETURN(res);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_List
////////////////////////////////////////////////////////////////////////////////

static void JS_List(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("listTree(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  // constructed listing
  v8::Handle<v8::Array> result = v8::Array::New(isolate);
  std::vector<std::string> list = TRI_FilesDirectory(*name);

  uint32_t j = 0;

  for (auto const& f : list) {
    result->Set(j++, TRI_V8_STD_STRING(isolate, f));
  }

  // return result
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_ListTree
////////////////////////////////////////////////////////////////////////////////

static void JS_ListTree(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("listTree(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  // constructed listing
  v8::Handle<v8::Array> result = v8::Array::New(isolate);
  std::vector<std::string> files(TRI_FullTreeDirectory(*name));

  uint32_t i = 0;
  for (auto const& it : files) {
    result->Set(i++, TRI_V8_STD_STRING(isolate, it));
  }

  // return result
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_MakeDirectory
////////////////////////////////////////////////////////////////////////////////

static void JS_MakeDirectory(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // 2nd argument (permissions) are ignored for now

  // extract arguments
  if (args.Length() != 1 && args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("makeDirectory(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  long systemError = 0;
  std::string systemErrorStr;
  int res = TRI_CreateDirectory(*name, systemError, systemErrorStr);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, systemErrorStr);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_MakeDirectoryRecursive
////////////////////////////////////////////////////////////////////////////////

static void JS_MakeDirectoryRecursive(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // 2nd argument (permissions) are ignored for now

  // extract arguments
  if (args.Length() != 1 && args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("makeDirectoryRecursive(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  long systemError = 0;
  std::string systemErrorStr;
  int res = TRI_CreateRecursiveDirectory(*name, systemError, systemErrorStr);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, systemErrorStr);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Unzip
////////////////////////////////////////////////////////////////////////////////

static void JS_UnzipFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 2) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "unzipFile(<filename>, <outPath>, <skipPaths>, <overwrite>, "
        "<password>)");
  }

  std::string const filename = TRI_ObjectToString(isolate, args[0]);
  std::string const outPath = TRI_ObjectToString(isolate, args[1]);

  bool skipPaths = false;
  if (args.Length() > 2) {
    skipPaths = TRI_ObjectToBoolean(isolate, args[2]);
  }

  bool overwrite = false;
  if (args.Length() > 3) {
    overwrite = TRI_ObjectToBoolean(isolate, args[3]);
  }

  char const* p = nullptr;
  std::string password;
  if (args.Length() > 4) {
    password = TRI_ObjectToString(isolate, args[4]);
    p = password.c_str();
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + filename);
  }

  if (!v8security.isAllowedToAccessPath(isolate, outPath, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + outPath);
  }

  std::string errMsg;
  int res = TRI_UnzipFile(filename.c_str(), outPath.c_str(), skipPaths, overwrite, p, errMsg);

  if (res == TRI_ERROR_NO_ERROR) {
    TRI_V8_RETURN_TRUE();
  }

  TRI_V8_THROW_EXCEPTION_MESSAGE(res, errMsg);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Zip
////////////////////////////////////////////////////////////////////////////////

static void JS_ZipFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 3 || args.Length() > 4) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "zipFile(<filename>, <chdir>, <files>, <password>)");
  }

  std::string const filename = TRI_ObjectToString(isolate, args[0]);
  std::string const dir = TRI_ObjectToString(isolate, args[1]);

  if (!args[2]->IsArray()) {
    TRI_V8_THROW_EXCEPTION_USAGE("<files> must be a list");
  }

  v8::Handle<v8::Array> files = v8::Handle<v8::Array>::Cast(args[2]);

  int res = TRI_ERROR_NO_ERROR;
  std::vector<std::string> filenames;

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(
                    TRI_ERROR_FORBIDDEN, std::string("not allowed to read files in this path: ") + filename);
  }
  if (!v8security.isAllowedToAccessPath(isolate, dir, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(
                    TRI_ERROR_FORBIDDEN, std::string("not allowed to read files in this path: ") + dir);
  }
  for (uint32_t i = 0; i < files->Length(); ++i) {
    v8::Handle<v8::Value> file = files->Get(i);
    if (file->IsString()) {
      if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::READ)) {
        THROW_ARANGO_EXCEPTION_MESSAGE(
            TRI_ERROR_FORBIDDEN, std::string("not allowed to read files in this path: ") + filename);
      }
      filenames.emplace_back(TRI_ObjectToString(isolate, file));
    } else {
      res = TRI_ERROR_BAD_PARAMETER;
      break;
    }
  }

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "zipFile(<filename>, <chdir>, <files>, <password>)");
  }

  char const* p = nullptr;
  std::string password;
  if (args.Length() == 4) {
    password = TRI_ObjectToString(isolate, args[3]);
    p = password.c_str();
  }

  if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + filename);
  }

  res = TRI_ZipFile(filename.c_str(), dir.c_str(), filenames, p);

  if (res == TRI_ERROR_NO_ERROR) {
    TRI_V8_RETURN_TRUE();
  }

  TRI_V8_THROW_EXCEPTION(res);
  TRI_V8_TRY_CATCH_END
}

static void JS_Adler32(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("adler32(<filename>, <useSigned>)");
  }

  bool useSigned = false;  // default is unsigned
  if (args.Length() > 1) {
    useSigned = TRI_ObjectToBoolean(isolate, args[1]);
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  uint32_t chksum = 0;
  int res = TRI_Adler32(*name, chksum);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION(res);
  }

  v8::Handle<v8::Value> result;

  if (useSigned) {
    result = v8::Number::New(isolate, static_cast<int32_t>(chksum));
  } else {
    result = v8::Number::New(isolate, chksum);
  }

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads a file and executes it
///
/// @FUN{internal.load(*filename*)}
///
/// Reads in a files and executes the contents in the current context.
////////////////////////////////////////////////////////////////////////////////

static void JS_Load(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("load(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  size_t length;
  char* content = TRI_SlurpFile(*name, &length);

  if (content == nullptr) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), "cannot read file");
  }

  v8::Handle<v8::Value> filename = args[0];

  // save state of __dirname and __filename
  v8::Handle<v8::Object> current = isolate->GetCurrentContext()->Global();
  auto oldFilename = TRI_GetProperty(context, isolate, current, "__filename");
  current->Set(TRI_V8_ASCII_STRING(isolate, "__filename"), filename);

  auto oldDirname = TRI_GetProperty(context, isolate, current, "__dirname");
  auto dirname = TRI_Dirname(TRI_ObjectToString(isolate, filename));
  current->Set(TRI_V8_ASCII_STRING(isolate, "__dirname"),
               TRI_V8_STD_STRING(isolate, dirname));

  v8::Handle<v8::Value> result;
  {
    v8::TryCatch tryCatch(isolate);

    result = TRI_ExecuteJavaScriptString(isolate, isolate->GetCurrentContext(),
                                         TRI_V8_PAIR_STRING(isolate, content, length),
                                         TRI_ObjectToString(context, filename), false);

    TRI_FreeString(content);

    // restore old values for __dirname and __filename
    if (oldFilename.IsEmpty() || oldFilename->IsUndefined()) {
      TRI_DeleteProperty(context, isolate, current, "__filename");
    } else {
      current->Set(TRI_V8_ASCII_STRING(isolate, "__filename"), oldFilename);
    }
    if (oldDirname.IsEmpty() || oldDirname->IsUndefined()) {
      TRI_DeleteProperty(context, isolate, current, "__dirname");
    } else {
      current->Set(TRI_V8_ASCII_STRING(isolate, "__dirname"), oldDirname);
    }
    if (result.IsEmpty()) {
      if (tryCatch.CanContinue()) {
        TRI_V8_LOG_THROW_EXCEPTION(tryCatch);
      } else {
        tryCatch.ReThrow();
        TRI_GET_GLOBALS();
        v8g->_canceled = true;
        TRI_V8_RETURN_UNDEFINED();
      }
    }
  }

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief logs a message
///
/// @FUN{internal.log(@FA{level}, @FA{message})}
///
/// Logs the @FA{message} at the given log @FA{level}.
///
/// Valid log-level are:
///
/// - fatal
/// - error
/// - warning
/// - info
/// - debug
/// - trace
////////////////////////////////////////////////////////////////////////////////

static void JS_Log(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("log(<level>, <message>)");
  }

  TRI_Utf8ValueNFC level(isolate, args[0]);

  if (*level == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<level> must be a string");
  }

  std::vector<std::string> splitted = StringUtils::split(*level, '=');

  std::string ls = "info";
  std::string ts = "";

  if (splitted.size() == 1) {
    ts = splitted[0];
  } else if (splitted.size() >= 2) {
    ts = splitted[0];
    ls = splitted[1];
  }

  std::string prefix;

  StringUtils::tolowerInPlace(ls);
  StringUtils::tolowerInPlace(ts);

  LogTopic const* topicPtr = ts.empty() ? nullptr : LogTopic::lookup(ts);
  LogTopic const& topic = (topicPtr != nullptr) ? *topicPtr : Logger::FIXME;

  if (args[1]->IsArray()) {
    auto loglines = v8::Handle<v8::Array>::Cast(args[1]);
    std::vector<std::string> logLineVec;

    logLineVec.reserve(loglines->Length());

    for (uint32_t i = 0; i < loglines->Length(); ++i) {
      v8::Handle<v8::Value> line = loglines->Get(i);
      TRI_Utf8ValueNFC message(isolate, line);
      if (line->IsString()) {
        logLineVec.push_back(*message);
      }
    }

    for (auto& message : logLineVec) {
      if (ls == "fatal") {
        prefix = "FATAL! ";
        LOG_TOPIC("ecbc6", ERR, topic) << prefix << message;
      } else if (ls == "error") {
        LOG_TOPIC("24213", ERR, topic) << prefix << message;
      } else if (ls == "warning" || ls == "warn") {
        LOG_TOPIC("514da", WARN, topic) << prefix << message;
      } else if (ls == "info") {
        LOG_TOPIC("99d80", INFO, topic) << prefix << message;
      } else if (ls == "debug") {
        LOG_TOPIC("f3533", DEBUG, topic) << prefix << message;
      } else if (ls == "trace") {
        LOG_TOPIC("74c21", TRACE, topic) << prefix << message;
      } else {
        prefix = ls + "!";
        LOG_TOPIC("6b817", WARN, topic) << prefix << message;
      }
    }  // for
  } else {
    TRI_Utf8ValueNFC message(isolate, args[1]);

    if (*message == nullptr) {
      TRI_V8_THROW_TYPE_ERROR("<message> must be a string or an array");
    }

    std::string msg = *message;

    if (ls == "fatal") {
      prefix = "FATAL! ";
      LOG_TOPIC("d1117", ERR, topic) << prefix << msg;
    } else if (ls == "error") {
      LOG_TOPIC("10407", ERR, topic) << prefix << msg;
    } else if (ls == "warning" || ls == "warn") {
      LOG_TOPIC("ebe22", WARN, topic) << prefix << msg;
    } else if (ls == "info") {
      LOG_TOPIC("365ec", INFO, topic) << prefix << msg;
    } else if (ls == "debug") {
      LOG_TOPIC("599b7", DEBUG, topic) << prefix << msg;
    } else if (ls == "trace") {
      LOG_TOPIC("42416", TRACE, topic) << prefix << msg;
    } else {
      prefix = ls + "!";
      LOG_TOPIC("0c009", WARN, topic) << prefix << msg;
    }
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief gets or sets the log-level
///
/// @FUN{internal.logLevel()}
///
/// Returns the current global log-level as string.
///
/// @FUN{internal.logLevel(true)}
///
/// Returns all topic log-level as vector of strings.
///
/// @FUN{internal.logLevel(@FA{level})}
///
/// Changes the current log-level. Valid log-level are:
///
/// - fatal
/// - error
/// - warning
/// - info
/// - debug
/// - trace
////////////////////////////////////////////////////////////////////////////////

static void JS_LogLevel(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (v8security.isInternalModuleHardened(isolate)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   "not allowed to change logLevel");
  }

  if (1 <= args.Length()) {
    if (args[0]->IsBoolean()) {
      auto levels = Logger::logLevelTopics();
      size_t n = levels.size();
      v8::Handle<v8::Array> object = v8::Array::New(isolate, static_cast<int>(n));

      uint32_t pos = 0;

      for (auto level : levels) {
        std::string output = level.first + "=" + Logger::translateLogLevel(level.second);
        v8::Handle<v8::String> val = TRI_V8_STD_STRING(isolate, output);

        object->Set(pos++, val);
      }

      TRI_V8_RETURN(object);
    } else {
      TRI_Utf8ValueNFC str(isolate, args[0]);
      Logger::setLogLevel(*str);
      TRI_V8_RETURN_UNDEFINED();
    }
  } else {
    auto level = Logger::translateLogLevel(Logger::logLevel());
    TRI_V8_RETURN_STD_STRING(level);
  }

  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the md5 sum of a text
///
/// @FUN{internal.md5(@FA{text})}
///
/// Computes an md5 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Md5(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("md5(<text>)");
  }

  v8::String::Utf8Value str(isolate, args[0]);

  if (*str == nullptr) {
    TRI_V8_RETURN_UNDEFINED();
  }

  // create md5
  char hash[17];
  char* p = &hash[0];
  size_t length;

  SslInterface::sslMD5(*str, str.length(), p, length);

  // as hex
  char hex[33];
  p = &hex[0];

  SslInterface::sslHEX(hash, 16, p, length);

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, 32);

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief generates random numbers
///
/// @FUN{internal.genRandomNumbers(@FA{length})}
///
/// Generates a string of a given @FA{length} containing numbers.
////////////////////////////////////////////////////////////////////////////////

static void JS_RandomNumbers(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1 || !args[0]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE("genRandomNumbers(<length>)");
  }

  int length = (int)TRI_ObjectToInt64(isolate, args[0]);

  if (length <= 0 || length > 65536) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                   "<length> must be between 0 and 65536");
  }

  std::string str = JSNumGenerator.random(length);
  TRI_V8_RETURN_STD_STRING(str);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief generates random alpha-numbers
///
/// @FUN{internal.genRandomAlphaNumbers(@FA{length})}
///
/// Generates a string of a given @FA{length} containing numbers and characters.
////////////////////////////////////////////////////////////////////////////////

static void JS_RandomAlphaNum(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1 || !args[0]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE("genRandomAlphaNumbers(<length>)");
  }

  int length = (int)TRI_ObjectToInt64(isolate, args[0]);
  if (length <= 0 || length > 65536) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                   "<length> must be between 0 and 65536");
  }

  std::string&& str = JSAlphaNumGenerator.random(length);
  TRI_V8_RETURN_STD_STRING(str);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief generates a salt
///
/// @FUN{internal.genRandomSalt(@FA{length})}
///
/// Generates a string of a given @FA{length} containing ASCII characters.
////////////////////////////////////////////////////////////////////////////////

static void JS_RandomSalt(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1 || !args[0]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE("genRandomSalt(<length>)");
  }

  int length = (int)TRI_ObjectToInt64(isolate, args[0]);
  if (length <= 0 || length > 65536) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                   "<length> must be between 0 and 65536");
  }

  std::string str = JSSaltGenerator.random(length);
  TRI_V8_RETURN_STD_STRING(str);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief generates a nonce
///
/// @FUN{internal.createNonce()}
///
/// Generates a base64 encoded nonce string. (length of the string is 16)
////////////////////////////////////////////////////////////////////////////////

static void JS_CreateNonce(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("createNonce()");
  }

  std::string str = Nonce::createNonce();

  TRI_V8_RETURN_STD_STRING(str);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief checks a base64 encoded nonce
///
/// @FUN{internal.checkAndMarkNonce(@FA{nonce})}
///
/// Checks and marks a @FA{nonce}
////////////////////////////////////////////////////////////////////////////////

static void JS_MarkNonce(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("checkAndMarkNonce(<nonce>)");
  }

  TRI_Utf8ValueNFC base64u(isolate, args[0]);

  if (*base64u == nullptr || base64u.length() != 16) {
    TRI_V8_THROW_TYPE_ERROR("expecting 16-Byte base64url-encoded nonce");
  }

  std::string raw = StringUtils::decodeBase64U(*base64u);

  if (raw.size() != 12) {
    TRI_V8_THROW_TYPE_ERROR("expecting 12-Byte nonce");
  }

  if (Nonce::checkAndMark(raw)) {
    TRI_V8_RETURN_TRUE();
  }
  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_MTime
////////////////////////////////////////////////////////////////////////////////

static void JS_MTime(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract two arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("mtime(<filename>)");
  }

  std::string filename = TRI_ObjectToString(isolate, args[0]);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, filename, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + filename);
  }

  int64_t mtime;
  int res = TRI_MTimeFile(filename.c_str(), &mtime);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION(res);
  }

  TRI_V8_RETURN(v8::Number::New(isolate, static_cast<double>(mtime)));
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_MoveFile
////////////////////////////////////////////////////////////////////////////////

static void JS_MoveFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract two arguments
  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("move(<source>, <destination>)");
  }

  std::string source = TRI_ObjectToString(isolate, args[0]);
  std::string destination = TRI_ObjectToString(isolate, args[1]);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, source, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + source);
  }

  if (!v8security.isAllowedToAccessPath(isolate, destination, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + destination);
  }

  bool const sourceIsDirectory = TRI_IsDirectory(source.c_str());
  bool const destinationIsDirectory = TRI_IsDirectory(destination.c_str());

  if (sourceIsDirectory && destinationIsDirectory) {
    // source is a directory, destination is a directory. this is unsupported
    TRI_V8_THROW_EXCEPTION_PARAMETER(
        "cannot move source directory into destination directory");
  }

  if (TRI_IsRegularFile(source.c_str()) && destinationIsDirectory) {
    // source is a file, destination is a directory. this is unsupported
    TRI_V8_THROW_EXCEPTION_PARAMETER(
        "cannot move source file into destination directory");
  }

  std::string systemErrorStr;
  long errorNo;

  int res = TRI_RenameFile(source.c_str(), destination.c_str(), &errorNo, &systemErrorStr);

  if (res != TRI_ERROR_NO_ERROR) {
    std::string errMsg = "cannot move file [" + source + "] to [" + destination +
                         " ] : " + std::to_string(errorNo) + ": " + systemErrorStr;
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, errMsg);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_CopyDirectoryRecursive
////////////////////////////////////////////////////////////////////////////////

static void JS_CopyRecursive(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract two arguments
  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("copyRecursive(<source>, <destination>)");
  }

  std::string source = TRI_ObjectToString(isolate, args[0]);
  std::string destination = TRI_ObjectToString(isolate, args[1]);

  bool const sourceIsDirectory = TRI_IsDirectory(source.c_str());
  bool const destinationIsDirectory = TRI_IsDirectory(destination.c_str());

  if (sourceIsDirectory && destinationIsDirectory) {
    // source is a directory, destination is a directory. this is unsupported
    TRI_V8_THROW_EXCEPTION_PARAMETER(
        "cannot copy source directory into destination directory");
  }

  if (TRI_IsRegularFile(source.c_str()) && destinationIsDirectory) {
    // source is a file, destination is a directory. this is unsupported
    TRI_V8_THROW_EXCEPTION_PARAMETER(
        "cannot copy source file into destination directory");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, source, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + source);
  }

  if (!v8security.isAllowedToAccessPath(isolate, destination, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + destination);
  }

  std::string systemErrorStr;
  long errorNo;
  int res = TRI_CreateRecursiveDirectory(destination.c_str(), errorNo, systemErrorStr);

  if (res != TRI_ERROR_NO_ERROR) {
    std::string errMsg = "cannot copy file [" + source + "] to [" +
                         destination + " ] : " + std::to_string(errorNo) +
                         " - Unable to create target directory: " + systemErrorStr;
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_SYS_ERROR, errMsg);
  }

  std::function<bool(std::string const&)> const passAllFilter =
      [](std::string const&) { return false; };

  if (!FileUtils::copyRecursive(source, destination, passAllFilter, systemErrorStr)) {
    std::string errMsg = "cannot copy directory [" + source + "] to [" + destination +
                         " ] : " + std::to_string(errorNo) + ": " + systemErrorStr;
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, errMsg);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_CopyFile
////////////////////////////////////////////////////////////////////////////////

static void JS_CopyFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract two arguments
  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("copyFile(<source>, <destination>)");
  }

  std::string source = TRI_ObjectToString(isolate, args[0]);
  std::string destination = TRI_ObjectToString(isolate, args[1]);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, source, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + source);
  }

  if (!v8security.isAllowedToAccessPath(isolate, destination, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + destination);
  }

  bool const destinationIsDirectory = TRI_IsDirectory(destination.c_str());

  if (!TRI_IsRegularFile(source.c_str())) {
    TRI_V8_THROW_EXCEPTION_PARAMETER("can only copy regular files.");
  }

  std::string systemErrorStr;

  if (destinationIsDirectory) {
    char const* file = strrchr(source.c_str(), TRI_DIR_SEPARATOR_CHAR);
    if (file == nullptr) {
      if (!destination.empty() && destination.back() != TRI_DIR_SEPARATOR_CHAR) {
        destination += TRI_DIR_SEPARATOR_CHAR;
      }
      destination += source;
    } else {
      destination += file;
    }
  }

  if (!TRI_CopyFile(source, destination, systemErrorStr)) {
    std::string errMsg = "cannot copy file [" + source + "] to [" +
                         destination + " ] : " + systemErrorStr;
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, errMsg);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_CopyFile
////////////////////////////////////////////////////////////////////////////////

static void JS_LinkFile(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract two arguments
  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("linkFile(<target>, <linkpath>)");
  }

  std::string target = TRI_ObjectToString(isolate, args[0]);
  std::string linkpath = TRI_ObjectToString(isolate, args[1]);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, target, FSAccessType::READ)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + target);
  }

  if (!v8security.isAllowedToAccessPath(isolate, linkpath, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + linkpath);
  }

  std::string systemErrorStr;

  if (!TRI_CreateSymbolicLink(target, linkpath, systemErrorStr)) {
    std::string errMsg = "cannot create a symlink from [" + target + "] to [" +
                         linkpath + " ] : " + systemErrorStr;
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER, errMsg);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads from stdin
////////////////////////////////////////////////////////////////////////////////

static void JS_PollStdin(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() > 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("pollStdin()");
  }

  bool hasData;
#ifdef _WIN32
  hasData = _kbhit() != 0;
#else
  struct timeval tv;
  fd_set fds;
  tv.tv_sec = 0;
  tv.tv_usec = 0;
  FD_ZERO(&fds);
  FD_SET(STDIN_FILENO, &fds);
  select(STDIN_FILENO + 1, &fds, nullptr, nullptr, &tv);
  hasData = FD_ISSET(STDIN_FILENO, &fds);
#endif

  if (hasData) {
    char c[3] = {0};
    ssize_t n = TRI_READ(STDIN_FILENO, c, 3);
    if (n == 3) {  // arrow keys are garbled
      if (c[2] == 'D') {
        TRI_V8_RETURN(v8::Integer::New(isolate, 37));
      }
      if (c[2] == 'A') {
        TRI_V8_RETURN(v8::Integer::New(isolate, 38));
      }
      if (c[2] == 'C') {
        TRI_V8_RETURN(v8::Integer::New(isolate, 39));
      }
    } else if (n == 1) {
      TRI_V8_RETURN(v8::Integer::New(isolate, c[0]));
    }
  }
  TRI_V8_RETURN(v8::Integer::New(isolate, 0));
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief outputs the arguments
///
/// @FUN{internal.output(@FA{string1}, @FA{string2}, @FA{string3}, ...)}
///
/// Outputs the arguments to standard output.
///
/// @verbinclude fluent39
////////////////////////////////////////////////////////////////////////////////

static void JS_Output(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  for (int i = 0; i < args.Length(); i++) {
    // extract the next argument
    v8::Handle<v8::Value> val = args[i];

    // convert it into a string
    // v8::String::Utf8Value utf8(val);
    TRI_Utf8ValueNFC utf8(isolate, val);

    if (*utf8 == nullptr) {
      continue;
    }

    // print the argument
    char const* ptr = *utf8;
    size_t len = utf8.length();

    while (0 < len) {
      ssize_t n = TRI_WRITE(STDOUT_FILENO, ptr, static_cast<TRI_write_t>(len));

      if (n < 0) {
        break;
      }

      len -= n;
      ptr += n;
    }
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns the current process information
/// `internal.processStatistics()`
///
/// Returns information about the current process:
///
/// - minorPageFaults: The number of minor faults the process has made
///   which have not required loading a memory page from disk.
///
/// - majorPageFaults: The number of major faults the process has made
///   which have required loading a memory page from disk.
///
/// - userTime: Amount of time that this process has been scheduled in
///   user mode, measured in clock ticks.
///
/// - systemTime: Amount of time that this process has been scheduled
///   in kernel mode, measured in clock ticks.
///
/// - numberOfThreads: Number of threads in this process.
///
/// - residentSize: Resident Set Size: total size of the number of pages
///   the process has in real memory.  This is just the pages which count
///   toward text, data, or stack space.  This does not include pages which
///   have not been demand-loaded in, or which are swapped out.
///
///   The resident set size is reported in bytes.
///
/// - residentSizePercent: resident size as percent of the total physical
///   memory size.
///
/// - virtualSize: Virtual memory size in bytes.
///
/// @EXAMPLE_ARANGOSH_OUTPUT{internalStatistics}
///   require("internal").processStat();
/// @END_EXAMPLE_ARANGOSH_OUTPUT
////////////////////////////////////////////////////////////////////////////////

static void ProcessStatisticsToV8(v8::FunctionCallbackInfo<v8::Value> const& args, ProcessInfo const& info) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  v8::Handle<v8::Object> result = v8::Object::New(isolate);

  double rss = (double)info._residentSize;
  double rssp = 0;

  if (TRI_PhysicalMemory != 0) {
    rssp = rss / TRI_PhysicalMemory;
  }

  result->Set(TRI_V8_ASCII_STRING(isolate, "minorPageFaults"),
              v8::Number::New(isolate, (double)info._minorPageFaults));
  result->Set(TRI_V8_ASCII_STRING(isolate, "majorPageFaults"),
              v8::Number::New(isolate, (double)info._majorPageFaults));
  result->Set(TRI_V8_ASCII_STRING(isolate, "userTime"),
              v8::Number::New(isolate, (double)info._userTime / (double)info._scClkTck));
  result->Set(TRI_V8_ASCII_STRING(isolate, "systemTime"),
              v8::Number::New(isolate, (double)info._systemTime / (double)info._scClkTck));
  result->Set(TRI_V8_ASCII_STRING(isolate, "numberOfThreads"),
              v8::Number::New(isolate, (double)info._numberThreads));
  result->Set(TRI_V8_ASCII_STRING(isolate, "residentSize"), v8::Number::New(isolate, rss));
  result->Set(TRI_V8_ASCII_STRING(isolate, "residentSizePercent"),
              v8::Number::New(isolate, rssp));
  result->Set(TRI_V8_ASCII_STRING(isolate, "virtualSize"),
              v8::Number::New(isolate, (double)info._virtualSize));

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

static void JS_ProcessStatisticsSelf(v8::FunctionCallbackInfo<v8::Value> const& args) {
  ProcessStatisticsToV8(args, TRI_ProcessInfoSelf());
}

static void JS_ProcessStatisticsExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "statisticsExternal(<external-identifier>)");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (v8security.isInternalModuleHardened(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  ExternalId pid;

  pid._pid = static_cast<TRI_pid_t>(TRI_ObjectToUInt64(isolate, args[0], true));

  ProcessStatisticsToV8(args, TRI_ProcessInfo(pid._pid));
  TRI_V8_TRY_CATCH_END
}

static void JS_GetPid(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (v8security.isInternalModuleHardened(isolate)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   "not allowed to provide this information");
  }

  // check arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("getPid()");
  }
  TRI_pid_t pid = Thread::currentProcessId();
  TRI_V8_RETURN_INTEGER(pid);

  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief generates a random number using OpenSSL
///
/// @FUN{internal.rand()}
///
/// Generates a random number
////////////////////////////////////////////////////////////////////////////////

static void JS_Rand(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // check arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("rand()");
  }

  int iterations = 0;
  while (iterations++ < 5) {
    int32_t value;
    int result = SslInterface::sslRand(&value);

    if (result != 0) {
      // error
      break;
    }

    // no error, now check what random number was produced

    if (value != 0) {
      // a number != 0 was produced. that is sufficient
      TRI_V8_RETURN(v8::Number::New(isolate, value));
    }

    // we don't want to return 0 as the result, so we try again
  }

  // we failed to produce a valid random number
  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Read
////////////////////////////////////////////////////////////////////////////////

static void JS_Read(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("read(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  size_t length;
  char* content = TRI_SlurpFile(*name, &length);

  if (content == nullptr) {
    std::string msg = TRI_last_error();
    msg += ": while reading ";
    msg += *name;
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), msg);
  }

  auto result = TRI_V8_PAIR_STRING(isolate, content, length);

  TRI_FreeString(content);

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_ReadBuffer
////////////////////////////////////////////////////////////////////////////////

static void JS_ReadBuffer(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("readBuffer(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  size_t length;
  char* content = TRI_SlurpFile(*name, &length);

  if (content == nullptr) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  V8Buffer* buffer = V8Buffer::New(isolate, content, length);

  TRI_FreeString(content);

  TRI_V8_RETURN(buffer->_handle);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_ReadGzip
////////////////////////////////////////////////////////////////////////////////

static void JS_ReadGzip(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("readGzip(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  size_t length;
  char* content = TRI_SlurpGzipFile(*name, &length);

  if (content == nullptr) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  auto result = TRI_V8_PAIR_STRING(isolate, content, length);

  TRI_FreeString(content);

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END

}

#ifdef USE_ENTERPRISE
////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_ReadGzip
////////////////////////////////////////////////////////////////////////////////

static void JS_ReadDecrypt(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("readDecrypt(<filename>,<keyfilename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  TRI_Utf8ValueNFC keyfile(isolate, args[1]);

  if (*keyfile == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<keyfilename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  if (!v8security.isAllowedToAccessPath(isolate, *keyfile, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *keyfile);
  }

  size_t length;
  auto& encryptionFeature = server.getFeature<EncryptionFeature>();
  char* content = TRI_SlurpDecryptFile(encryptionFeature, *name, *keyfile, &length);

  if (content == nullptr) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  auto result = TRI_V8_PAIR_STRING(isolate, content, length);

  TRI_FreeString(content);

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END

}
#endif

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Read64
////////////////////////////////////////////////////////////////////////////////

static void JS_Read64(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("read(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a UTF-8 string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  std::string base64;

  try {
    std::string content = FileUtils::slurp(*name);
    base64 = StringUtils::encodeBase64(content);
  } catch (...) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_errno(), TRI_last_error());
  }

  TRI_V8_RETURN_STD_STRING(base64);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief append to a file
////////////////////////////////////////////////////////////////////////////////

static void JS_Append(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() != 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("append(<filename>, <content>)");
  }

#if _WIN32  // the wintendo needs utf16 filenames
  v8::String::Value str(isolate, args[0]);
  std::wstring name{reinterpret_cast<wchar_t*>(*str), static_cast<size_t>(str.length())};
  TRI_Utf8ValueNFC utf8Str(isolate, args[0]);
  std::string utf8Name(*utf8Str, utf8Str.length());
#else
  TRI_Utf8ValueNFC str(isolate, args[0]);
  std::string name(*str, str.length());
  std::string const& utf8Name = name;
#endif

  if (name.empty()) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a non-empty string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, utf8Name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + utf8Name);
  }

  std::ofstream file;

  if (args[1]->IsObject() && V8Buffer::hasInstance(isolate, args[1])) {
    // content is a buffer
    char const* data = V8Buffer::data(isolate, args[1].As<v8::Object>());
    size_t size = V8Buffer::length(isolate, args[1].As<v8::Object>());

    if (data == nullptr) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                     "invalid <content> buffer value");
    }

    file.open(name, std::ios::out | std::ios::binary | std::ios::app);

    if (file.is_open()) {
      file.write(data, size);
      file.close();
      TRI_V8_RETURN_TRUE();
    }
  } else {
    TRI_Utf8ValueNFC content(isolate, args[1]);

    if (*content == nullptr) {
      TRI_V8_THROW_TYPE_ERROR("<content> must be a string");
    }

    file.open(name, std::ios::out | std::ios::binary | std::ios::app);

    if (file.is_open()) {
      file.write(*content, content.length());
      file.close();
      TRI_V8_RETURN_TRUE();
    }
  }

  TRI_V8_THROW_EXCEPTION_SYS("cannot write file");
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief write to a file
////////////////////////////////////////////////////////////////////////////////

static void JS_Write(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  if (args.Length() < 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("write(<filename>, <content>)");
  }
#if _WIN32  // the wintendo needs utf16 filenames
  v8::String::Value str(isolate, args[0]);
  std::wstring name{reinterpret_cast<wchar_t*>(*str), static_cast<size_t>(str.length())};
  TRI_Utf8ValueNFC utf8Str(isolate, args[0]);
  std::string utf8Name(*utf8Str, utf8Str.length());
#else
  TRI_Utf8ValueNFC str(isolate, args[0]);
  std::string name(*str, str.length());
  std::string const& utf8Name = name;
#endif

  if (name.length() == 0) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, utf8Name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + utf8Name);
  }

  bool flush = false;
  if (args.Length() > 2) {
    flush = TRI_ObjectToBoolean(isolate, args[2]);
  }

  if (args[1]->IsObject() && V8Buffer::hasInstance(isolate, args[1])) {
    // content is a buffer
    char const* data = V8Buffer::data(isolate, args[1].As<v8::Object>());
    size_t size = V8Buffer::length(isolate, args[1].As<v8::Object>());

    if (data == nullptr) {
      TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                     "invalid <content> buffer value");
    }

    std::fstream file;

    errno = 0;
    // disable exceptions in the stream object:
    file.exceptions(std::ifstream::goodbit);
    file.open(name, std::ios::out | std::ios::binary);

    if (file.is_open() && file.good()) {
      file.write(data, size);
      if (file.good()) {
        if (flush) {
          file.flush();
          file.sync();
        }
        file.close();
        if (file.good()) {
          TRI_V8_RETURN_TRUE();
        }
      } else {
        file.close();
      }
    }
  } else {
    TRI_Utf8ValueNFC content(isolate, args[1]);

    if (*content == nullptr) {
      TRI_V8_THROW_TYPE_ERROR("<content> must be a string");
    }

    std::fstream file;

    errno = 0;
    // disable exceptions in the stream object:
    file.exceptions(std::ifstream::goodbit);
    file.open(name, std::ios::out | std::ios::binary);

    if (file.is_open() && file.good()) {
      file << *content;
      if (file.good()) {
        if (flush) {
          file.flush();
          file.sync();
        }
        file.close();
        if (file.good()) {
          TRI_V8_RETURN_TRUE();
        }
      } else {
        file.close();
      }
    }
  }

  TRI_V8_THROW_EXCEPTION_SYS("cannot write file");
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_Remove
////////////////////////////////////////////////////////////////////////////////

static void JS_Remove(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("remove(<filename>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  int res = TRI_UnlinkFile(*name);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, "cannot remove file");
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_RemoveDirectory
////////////////////////////////////////////////////////////////////////////////

static void JS_RemoveDirectory(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("removeDirectory(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  if (!TRI_IsDirectory(*name)) {
    std::string err =
        std::string("<path> must be a valid directory name (have '") + *name +
        "')";
    TRI_V8_THROW_EXCEPTION_PARAMETER(err);
  }

  int res = TRI_RemoveEmptyDirectory(*name);

  if (res != TRI_ERROR_NO_ERROR) {
    std::string err = std::string("cannot remove directory: ") + *name + "'";
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, err);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief was docuBlock JS_RemoveDirectoryRecursive
////////////////////////////////////////////////////////////////////////////////

static void JS_RemoveRecursiveDirectory(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("removeDirectoryRecursive(<path>)");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<path> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::WRITE)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to modify files in this path: ") + *name);
  }

  if (!TRI_IsDirectory(*name)) {
    std::string err =
        std::string("<path> must be a valid directory name (have '") + *name +
        "')";
    TRI_V8_THROW_EXCEPTION_PARAMETER(err);
  }

  bool force = false;

  if (args.Length() > 1) {
    force = TRI_ObjectToBoolean(isolate, args[1]);
  }

  if (!force) {
    // check if we're inside the temp directory. force will override this check
    std::string tempPath = TRI_GetTempPath();

    if (tempPath.size() < 6) {
      TRI_V8_THROW_EXCEPTION_PARAMETER(
          "temporary directory name is too short. will not remove directory");
    }

    std::string const path(*name);

#ifdef _WIN32
    // windows paths are case-insensitive
    if (!TRI_CaseEqualString(path.c_str(), tempPath.c_str(), tempPath.size())) {
#else
    if (!TRI_EqualString(path.c_str(), tempPath.c_str(), tempPath.size())) {
#endif
      std::string errorMessage = std::string("directory to be removed [") +
                                 path + "] is outside of temporary path [" +
                                 tempPath + "]";
      TRI_V8_THROW_EXCEPTION_PARAMETER(errorMessage);
    }
  }

  int res = TRI_RemoveDirectory(*name);

  if (res != TRI_ERROR_NO_ERROR) {
    std::string err = std::string("cannot remove directory: ") + *name + "'";
    TRI_V8_THROW_EXCEPTION_MESSAGE(res, err);
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief formats the arguments
///
/// @FUN{internal.sprintf(@FA{format}, @FA{argument1}, ...)}
///
/// Formats the arguments according to the format string @FA{format}.
////////////////////////////////////////////////////////////////////////////////

static void JS_SPrintF(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  size_t len = args.Length();

  if (len == 0) {
    TRI_V8_RETURN_STRING("");
  }

  TRI_Utf8ValueNFC format(isolate, args[0]);

  if (*format == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<format> must be a UTF-8 string");
  }

  std::string result;

  size_t p = 1;

  for (char const* ptr = *format; *ptr; ++ptr) {
    if (*ptr == '%') {
      ++ptr;

      switch (*ptr) {
        case '%':
          result += '%';
          break;

        case 'd':
        case 'f':
        case 'i': {
          if (len <= p) {
            result += "%";
            result += *ptr;
          } else {
            bool e;
            double f = TRI_ObjectToDouble(isolate, args[(int)p], e);

            if (e) {
              result += "NaN";
            } else {
              char b[1024];

              if (*ptr == 'f') {
                snprintf(b, sizeof(b), "%f", f);
              } else {
                snprintf(b, sizeof(b), "%ld", (long)f);
              }

              result += b;
            }

            ++p;
          }

          break;
        }

        case 'o':
        case 's': {
          if (len <= p) {
            result += "%";
            result += *ptr;
          } else {
            TRI_Utf8ValueNFC text(isolate, args[(int)p]);

            if (*text == nullptr) {
              std::string msg = StringUtils::itoa(p) +
                                ".th argument must be a string in format '" +
                                *format + "'";
              TRI_V8_THROW_EXCEPTION_PARAMETER(msg.c_str());
            }

            ++p;

            result += *text;
          }

          break;
        }

        default:
          result += "%";
          result += *ptr;
          break;
      }
    } else {
      result += *ptr;
    }
  }

  for (size_t i = p; i < len; ++i) {
    TRI_Utf8ValueNFC text(isolate, args[(int)i]);

    if (*text == nullptr) {
      std::string msg = StringUtils::itoa(i) +
                        ".th argument must be a string in format '" + *format +
                        "'";
      TRI_V8_THROW_TYPE_ERROR(msg.c_str());
    }

    result += " ";
    result += *text;
  }

  TRI_V8_RETURN_STD_STRING(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the sha512 sum
///
/// @FUN{internal.sha512(@FA{text})}
///
/// Computes an sha512 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sha512(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("sha512(<text>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);

  // create sha512
  char* hash = nullptr;
  size_t hashLen;

  SslInterface::sslSHA512(key.c_str(), key.size(), hash, hashLen);

  // as hex
  char* hex = nullptr;
  size_t hexLen;

  SslInterface::sslHEX(hash, hashLen, hex, hexLen);

  delete[] hash;

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, (int)hexLen);

  delete[] hex;

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the sha384 sum
///
/// @FUN{internal.sha384(@FA{text})}
///
/// Computes an sha384 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sha384(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("sha384(<text>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);

  // create sha384
  char* hash = nullptr;
  size_t hashLen;

  SslInterface::sslSHA384(key.c_str(), key.size(), hash, hashLen);

  // as hex
  char* hex = nullptr;
  size_t hexLen;

  SslInterface::sslHEX(hash, hashLen, hex, hexLen);

  delete[] hash;

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, (int)hexLen);

  delete[] hex;

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the sha256 sum
///
/// @FUN{internal.sha256(@FA{text})}
///
/// Computes an sha256 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sha256(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("sha256(<text>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);

  // create sha256
  char* hash = nullptr;
  size_t hashLen;

  SslInterface::sslSHA256(key.c_str(), key.size(), hash, hashLen);

  // as hex
  char* hex = nullptr;
  size_t hexLen;

  SslInterface::sslHEX(hash, hashLen, hex, hexLen);

  delete[] hash;

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, (int)hexLen);

  delete[] hex;

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the sha224 sum
///
/// @FUN{internal.sha224(@FA{text})}
///
/// Computes an sha224 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sha224(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("sha224(<text>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);

  // create sha224
  char* hash = nullptr;
  size_t hashLen;

  SslInterface::sslSHA224(key.c_str(), key.size(), hash, hashLen);

  // as hex
  char* hex = nullptr;
  size_t hexLen;

  SslInterface::sslHEX(hash, hashLen, hex, hexLen);

  delete[] hash;

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, (int)hexLen);

  delete[] hex;

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the sha1 sum
///
/// @FUN{internal.sha1(@FA{text})}
///
/// Computes an sha1 for the @FA{text}.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sha1(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1 || !args[0]->IsString()) {
    TRI_V8_THROW_EXCEPTION_USAGE("sha1(<text>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);

  // create sha1
  char* hash = nullptr;
  size_t hashLen;

  SslInterface::sslSHA1(key.c_str(), key.size(), hash, hashLen);

  // as hex
  char* hex = nullptr;
  size_t hexLen;

  SslInterface::sslHEX(hash, hashLen, hex, hexLen);

  delete[] hash;

  // and return
  v8::Handle<v8::String> hashStr = TRI_V8_PAIR_STRING(isolate, hex, (int)hexLen);

  delete[] hex;

  TRI_V8_RETURN(hashStr);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief sleeps
///
/// @FUN{internal.sleep(@FA{seconds})}
///
/// Wait for @FA{seconds}, without calling the garbage collection.
////////////////////////////////////////////////////////////////////////////////

static void JS_Sleep(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("sleep(<seconds>)");
  }

  double n = TRI_ObjectToDouble(isolate, args[0]);
  double until = TRI_microtime() + n;

  while (true) {
    double now = TRI_microtime();
    if (now >= until) {
      break;
    }
    uint64_t duration =
        (until - now >= 0.5) ? 500000 : static_cast<uint64_t>((until - now) * 1000000);

    std::this_thread::sleep_for(std::chrono::microseconds(duration));
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns the current time
///
/// @FUN{internal.time()}
///
/// Returns the current time in seconds.
///
/// @verbinclude fluent36
////////////////////////////////////////////////////////////////////////////////

static void JS_Time(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  TRI_V8_RETURN(v8::Number::New(isolate, TRI_microtime()));
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief waits for the specified amount of time and calls the garbage
/// collection.
///
/// @FUN{internal.wait(@FA{seconds})}
///
/// Wait for @FA{seconds}, call the garbage collection.
////////////////////////////////////////////////////////////////////////////////

static void JS_Wait(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("wait(<seconds>, <gc>)");
  }

  double n = TRI_ObjectToDouble(isolate, args[0]);

  bool gc = true;  // default is to trigger the gc
  if (args.Length() > 1) {
    gc = TRI_ObjectToBoolean(isolate, args[1]);
  }

  if (gc) {
    TRI_RunGarbageCollectionV8(isolate, n);
  }

  // wait without gc
  double until = TRI_microtime() + n;
  while (TRI_microtime() < until) {
    std::this_thread::sleep_for(std::chrono::milliseconds(1));
  }

  TRI_V8_RETURN_UNDEFINED();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns whether failure points can be used
///
/// @FUN{internal.debugCanUseFailAt()}
///
/// Returns whether failure points can be be used
////////////////////////////////////////////////////////////////////////////////

static void JS_DebugCanUseFailAt(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("debugCanUseFailAt()");
  }

  if (TRI_CanUseFailurePointsDebugging()) {
    TRI_V8_RETURN_TRUE();
  }
  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the PBKDF2 HMAC SHA1 derived key
///
/// @FUN{internal.PBKDF2HS1(@FA{salt}, @FA{password}, @FA{iterations},
/// @FA{keyLength})}
///
/// Computes the PBKDF2 HMAC SHA1 derived key for the @FA{password}.
////////////////////////////////////////////////////////////////////////////////

static void JS_PBKDF2HS1(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 4 || !args[0]->IsString() || !args[1]->IsString() ||
      !args[2]->IsNumber() || !args[3]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "PBKDF2(<salt>, <password>, <iterations>, <keyLength>)");
  }

  std::string salt = TRI_ObjectToString(isolate, args[0]);
  std::string password = TRI_ObjectToString(isolate, args[1]);
  int iterations = (int)TRI_ObjectToInt64(isolate, args[2]);
  int keyLength = (int)TRI_ObjectToInt64(isolate, args[3]);

  std::string result =
      SslInterface::sslPBKDF2HS1(salt.c_str(), salt.size(), password.c_str(),
                                 password.size(), iterations, keyLength);
  TRI_V8_RETURN_STD_STRING(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the PBKDF2 HMAC derived key
///
/// @FUN{internal.PBKDF2(@FA{salt}, @FA{password}, @FA{iterations},
/// @FA{keyLength}, @FA{algorithm})}
///
/// Computes the PBKDF2 HMAC derived key for the @FA{password}.
////////////////////////////////////////////////////////////////////////////////

static void JS_PBKDF2(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate)
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 4 || !args[0]->IsString() || !args[1]->IsString() ||
      !args[2]->IsNumber() || !args[3]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "PBKDF2_SHA(<salt>, <password>, <iterations>, <keyLength>, "
        "<algorithm>)");
  }

  SslInterface::Algorithm al = SslInterface::Algorithm::ALGORITHM_SHA1;
  if (args.Length() > 4 && !args[4]->IsUndefined()) {
    std::string algorithm = TRI_ObjectToString(isolate, args[4]);
    StringUtils::tolowerInPlace(algorithm);

    if (algorithm == "sha1") {
      al = SslInterface::Algorithm::ALGORITHM_SHA1;
    } else if (algorithm == "sha512") {
      al = SslInterface::Algorithm::ALGORITHM_SHA512;
    } else if (algorithm == "sha384") {
      al = SslInterface::Algorithm::ALGORITHM_SHA384;
    } else if (algorithm == "sha256") {
      al = SslInterface::Algorithm::ALGORITHM_SHA256;
    } else if (algorithm == "sha224") {
      al = SslInterface::Algorithm::ALGORITHM_SHA224;
    } else if (algorithm == "md5") {
      al = SslInterface::Algorithm::ALGORITHM_MD5;
    } else {
      TRI_V8_THROW_EXCEPTION_PARAMETER("invalid value for <algorithm>");
    }
  }

  std::string salt = TRI_ObjectToString(isolate, args[0]);
  std::string password = TRI_ObjectToString(isolate, args[1]);
  int iterations = (int)TRI_ObjectToInt64(isolate, args[2]);
  int keyLength = (int)TRI_ObjectToInt64(isolate, args[3]);

  std::string result =
      SslInterface::sslPBKDF2(salt.c_str(), salt.size(), password.c_str(),
                              password.size(), iterations, keyLength, al);
  TRI_V8_RETURN_STD_STRING(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief computes the HMAC signature
///
/// @FUN{internal.HMAC(@FA{key}, @FA{message}, @FA{algorithm})}
///
/// Computes the HMAC for the @FA{message}.
////////////////////////////////////////////////////////////////////////////////

static void JS_HMAC(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract arguments
  if (args.Length() < 2) {
    TRI_V8_THROW_EXCEPTION_USAGE("HMAC(<key>, <text>, <algorithm>)");
  }

  std::string key = TRI_ObjectToString(isolate, args[0]);
  std::string message = TRI_ObjectToString(isolate, args[1]);

  SslInterface::Algorithm al = SslInterface::Algorithm::ALGORITHM_SHA256;
  if (args.Length() > 2 && !args[2]->IsUndefined()) {
    std::string algorithm = TRI_ObjectToString(isolate, args[2]);
    StringUtils::tolowerInPlace(algorithm);

    if (algorithm == "sha1") {
      al = SslInterface::Algorithm::ALGORITHM_SHA1;
    } else if (algorithm == "sha512") {
      al = SslInterface::Algorithm::ALGORITHM_SHA512;
    } else if (algorithm == "sha384") {
      al = SslInterface::Algorithm::ALGORITHM_SHA384;
    } else if (algorithm == "sha256") {
      al = SslInterface::Algorithm::ALGORITHM_SHA256;
    } else if (algorithm == "sha224") {
      al = SslInterface::Algorithm::ALGORITHM_SHA224;
    } else if (algorithm == "md5") {
      al = SslInterface::Algorithm::ALGORITHM_MD5;
    } else {
      TRI_V8_THROW_EXCEPTION_PARAMETER("invalid value for <algorithm>");
    }
  }

  std::string v = SslInterface::sslHMAC(key.c_str(), key.size(),
                                        message.c_str(), message.size(), al);

  std::string result = StringUtils::encodeHex(v.data(), v.size());
  TRI_V8_RETURN_STD_STRING(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief Convert programm stati to V8
////////////////////////////////////////////////////////////////////////////////
static char const* convertProcessStatusToString(TRI_external_status_e processStatus) {
  char const* status = "UNKNOWN";

  switch (processStatus) {
    case TRI_EXT_NOT_STARTED:
      status = "NOT-STARTED";
      break;
    case TRI_EXT_PIPE_FAILED:
      status = "FAILED";
      break;
    case TRI_EXT_FORK_FAILED:
      status = "FAILED";
      break;
    case TRI_EXT_RUNNING:
      status = "RUNNING";
      break;
    case TRI_EXT_NOT_FOUND:
      status = "NOT-FOUND";
      break;
    case TRI_EXT_TERMINATED:
      status = "TERMINATED";
      break;
    case TRI_EXT_ABORTED:
      status = "ABORTED";
      break;
    case TRI_EXT_STOPPED:
      status = "STOPPED";
      break;
    case TRI_EXT_TIMEOUT:
      status = "TIMEOUT";
      break;
  }
  return status;
}

static void convertPipeStatus(v8::FunctionCallbackInfo<v8::Value> const& args,
                              v8::Handle<v8::Object>& result, ExternalId const& external) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);

  result->Set(TRI_V8_ASCII_STRING(isolate, "pid"),
              v8::Number::New(isolate, external._pid));

  // Now report about possible stdin and stdout pipes:
#ifndef _WIN32
  if (external._readPipe >= 0) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "readPipe"),
                v8::Number::New(isolate, external._readPipe));
  }
  if (external._writePipe >= 0) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "writePipe"),
                v8::Number::New(isolate, external._writePipe));
  }
#else
  if (external._readPipe != INVALID_HANDLE_VALUE) {
    auto fn = getFileNameFromHandle(external._readPipe);
    if (fn.length() > 0) {
      result->Set(TRI_V8_ASCII_STRING(isolate, "readPipe"), TRI_V8_STD_STRING(isolate, fn));
    }
  }
  if (external._writePipe != INVALID_HANDLE_VALUE) {
    auto fn = getFileNameFromHandle(external._writePipe);
    if (fn.length() > 0) {
      result->Set(TRI_V8_ASCII_STRING(isolate, "writePipe"),
                  TRI_V8_STD_STRING(isolate, fn));
    }
  }
#endif
  TRI_V8_TRY_CATCH_END;
}

static void convertStatusToV8(v8::FunctionCallbackInfo<v8::Value> const& args,
                              v8::Handle<v8::Object>& result,
                              ExternalProcessStatus const& external_status,
                              ExternalId const& external) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);

  convertPipeStatus(args, result, external);

  result->Set(TRI_V8_ASCII_STRING(isolate, "status"),
              TRI_V8_ASCII_STRING(isolate, convertProcessStatusToString(
                                               external_status._status)));

  if (external_status._status == TRI_EXT_TERMINATED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "exit"),
                v8::Integer::New(isolate, static_cast<int32_t>(external_status._exitStatus)));
  } else if (external_status._status == TRI_EXT_ABORTED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "signal"),
                v8::Integer::New(isolate, static_cast<int32_t>(external_status._exitStatus)));
  }
  if (external_status._errorMessage.length() > 0) {
    result->Set(TRI_V8_STD_STRING(isolate, StaticStrings::ErrorMessage),
                TRI_V8_STD_STRING(isolate, external_status._errorMessage));
  }
  TRI_V8_TRY_CATCH_END;
}

static void convertProcessInfoToV8(v8::FunctionCallbackInfo<v8::Value> const& args,
                                   v8::Handle<v8::Object>& result,
                                   ExternalProcess const& external_process) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);

  convertPipeStatus(args, result, external_process);

  result->Set(TRI_V8_ASCII_STRING(isolate, "status"),
              TRI_V8_ASCII_STRING(isolate, convertProcessStatusToString(
                                               external_process._status)));

  if (external_process._status == TRI_EXT_TERMINATED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "exit"),
                v8::Integer::New(isolate, static_cast<int32_t>(external_process._exitStatus)));
  } else if (external_process._status == TRI_EXT_ABORTED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "signal"),
                v8::Integer::New(isolate, static_cast<int32_t>(external_process._exitStatus)));
  }
  result->Set(TRI_V8_ASCII_STRING(isolate, "executable"),
              TRI_V8_STD_STRING(isolate, external_process._executable));

  v8::Handle<v8::Array> arguments =
      v8::Array::New(isolate, static_cast<int>(external_process._numberArguments));
  for (uint32_t i = 0; i < external_process._numberArguments; i++) {
    arguments->Set(i, TRI_V8_ASCII_STRING(isolate, external_process._arguments[i]));
  }
  result->Set(TRI_V8_ASCII_STRING(isolate, "arguments"), arguments);
  TRI_V8_TRY_CATCH_END;
}
////////////////////////////////////////////////////////////////////////////////
/// @brief lists all running external processes
////////////////////////////////////////////////////////////////////////////////

static void JS_GetExternalSpawned(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("getExternalSpawned()");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  v8::Handle<v8::Array> spawnedProcesses =
      v8::Array::New(isolate, static_cast<int>(ExternalProcesses.size()));

  uint32_t i = 0;
  for (auto const& process : ExternalProcesses) {
    v8::Handle<v8::Object> oneProcess = v8::Object::New(isolate);
    convertProcessInfoToV8(args, oneProcess, *process);
    spawnedProcesses->Set(i, oneProcess);
    i++;
  }

  TRI_V8_RETURN(spawnedProcesses);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes a external program
////////////////////////////////////////////////////////////////////////////////

static void JS_ExecuteExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (4 < args.Length() || args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "executeExternal(<filename>[, <arguments> [,<usePipes> [,<env>] ] ])");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a string");
  }

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  std::vector<std::string> arguments;

  if (2 <= args.Length()) {
    v8::Handle<v8::Value> a = args[1];

    if (a->IsArray()) {
      v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(a);

      uint32_t n = arr->Length();

      for (uint32_t i = 0; i < n; ++i) {
        TRI_Utf8ValueNFC arg(isolate, arr->Get(i));

        if (*arg == nullptr) {
          arguments.push_back("");
        } else {
          arguments.push_back(*arg);
        }
      }
    } else {
      TRI_Utf8ValueNFC arg(isolate, a);

      if (*arg == nullptr) {
        arguments.push_back("");
      } else {
        arguments.push_back(*arg);
      }
    }
  }

  std::vector<std::string> additionalEnv;

  if (4 <= args.Length()) {
    v8::Handle<v8::Value> a = args[3];

    if (a->IsArray()) {
      v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(a);

      uint32_t n = arr->Length();

      for (uint32_t i = 0; i < n; ++i) {
        TRI_Utf8ValueNFC arg(isolate, arr->Get(i));

        if (*arg == nullptr) {
          additionalEnv.push_back("");
        } else {
          additionalEnv.push_back(*arg);
        }
      }
    }
  }

  bool usePipes = false;

  if (3 <= args.Length()) {
    usePipes = TRI_ObjectToBoolean(isolate, args[2]);
  }

  ExternalId external;
  TRI_CreateExternalProcess(*name, arguments, additionalEnv, usePipes, &external);

  if (external._pid == TRI_INVALID_PROCESS_ID) {
    TRI_V8_THROW_ERROR("Process could not be started");
  }
  v8::Handle<v8::Object> result = v8::Object::New(isolate);

  convertPipeStatus(args, result, external);

  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns the status of an external process
////////////////////////////////////////////////////////////////////////////////

static void JS_StatusExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() < 1 || args.Length() > 3) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "statusExternal(<external-identifier>[, <wait>[, <timeoutms>]])");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  ExternalId pid;

  pid._pid = static_cast<TRI_pid_t>(TRI_ObjectToUInt64(isolate, args[0], true));
  bool wait = false;
  if (args.Length() >= 2) {
    wait = TRI_ObjectToBoolean(isolate, args[1]);
  }
  uint32_t timeoutms = 0;
  if (args.Length() >= 2) {
    timeoutms = static_cast<uint32_t>(TRI_ObjectToUInt64(isolate, args[2], true));
  }

  ExternalProcessStatus external = TRI_CheckExternalProcess(pid, wait, timeoutms);

  v8::Handle<v8::Object> result = v8::Object::New(isolate);

  result->Set(TRI_V8_ASCII_STRING(isolate, "status"),
              TRI_V8_STRING(isolate, convertProcessStatusToString(external._status)));

  if (external._status == TRI_EXT_TERMINATED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "exit"),
                v8::Integer::New(isolate, static_cast<int32_t>(external._exitStatus)));
  } else if (external._status == TRI_EXT_ABORTED) {
    result->Set(TRI_V8_ASCII_STRING(isolate, "signal"),
                v8::Integer::New(isolate, static_cast<int32_t>(external._exitStatus)));
  }
  if (external._errorMessage.length() > 0) {
    result->Set(TRI_V8_STD_STRING(isolate, StaticStrings::ErrorMessage),
                TRI_V8_STD_STRING(isolate, external._errorMessage));
  }
  // return the result
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes a external program
////////////////////////////////////////////////////////////////////////////////

static void JS_ExecuteAndWaitExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (5 < args.Length() || args.Length() < 1) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "executeExternalAndWait(<filename>[, <arguments> [,<usePipes>, [, <timeoutms> [, <env>] ] ] ])");
  }

  TRI_Utf8ValueNFC name(isolate, args[0]);

  if (*name == nullptr) {
    TRI_V8_THROW_TYPE_ERROR("<filename> must be a string");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  if (!v8security.isAllowedToAccessPath(isolate, *name, FSAccessType::READ)) {
    THROW_ARANGO_EXCEPTION_MESSAGE(TRI_ERROR_FORBIDDEN,
                                   std::string("not allowed to read files in this path: ") + *name);
  }

  std::vector<std::string> arguments;

  if (2 <= args.Length()) {
    v8::Handle<v8::Value> a = args[1];

    if (a->IsArray()) {
      v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(a);

      uint32_t const n = arr->Length();

      for (uint32_t i = 0; i < n; ++i) {
        TRI_Utf8ValueNFC arg(isolate, arr->Get(i));

        if (*arg == nullptr) {
          arguments.push_back("");
        } else {
          arguments.push_back(*arg);
        }
      }
    } else {
      TRI_Utf8ValueNFC arg(isolate, a);

      if (*arg == nullptr) {
        arguments.push_back("");
      } else {
        arguments.push_back(*arg);
      }
    }
  }

  std::vector<std::string> additionalEnv;

  if (5 <= args.Length()) {
    v8::Handle<v8::Value> a = args[4];

    if (a->IsArray()) {
      v8::Handle<v8::Array> arr = v8::Handle<v8::Array>::Cast(a);

      uint32_t n = arr->Length();

      for (uint32_t i = 0; i < n; ++i) {
        TRI_Utf8ValueNFC arg(isolate, arr->Get(i));

        if (*arg == nullptr) {
          additionalEnv.push_back("");
        } else {
          additionalEnv.push_back(*arg);
        }
      }
    }
  }

  bool usePipes = false;
  if (args.Length() >= 3) {
    usePipes = TRI_ObjectToBoolean(isolate, args[2]);
  }

  uint32_t timeoutms = 0;
  if (args.Length() >= 4) {
    timeoutms = static_cast<uint32_t>(TRI_ObjectToUInt64(isolate, args[3], true));
  }

  ExternalId external;
  TRI_CreateExternalProcess(*name, arguments, additionalEnv, usePipes, &external);

  if (external._pid == TRI_INVALID_PROCESS_ID) {
    TRI_V8_THROW_ERROR("Process could not be started");
  }
  v8::Handle<v8::Object> result = v8::Object::New(isolate);

  ExternalId pid;
  pid._pid = external._pid;

  auto external_status = TRI_CheckExternalProcess(pid, true, timeoutms);

  convertStatusToV8(args, result, external_status, external);

  // return the result
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief kills an external process
////////////////////////////////////////////////////////////////////////////////

static void JS_KillExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() < 1 || args.Length() > 2) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "killExternal(<external-identifier>[[, <signal>], isTerminal])");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  int signal = SIGTERM;
  if (args.Length() >= 2) {
    signal = static_cast<int>(TRI_ObjectToInt64(isolate, args[1]));
  }

  bool isTerminating;
  if (args.Length() >= 3) {
    isTerminating = TRI_ObjectToBoolean(isolate, args[2]);
  } else {
    isTerminating = TRI_IsDeadlySignal(signal);
  }

  ExternalId pid;

#ifndef _WIN32
  pid._pid = static_cast<TRI_pid_t>(TRI_ObjectToUInt64(isolate, args[0], true));
#else
  pid._pid = static_cast<DWORD>(TRI_ObjectToUInt64(isolate, args[0], true));
#endif
  if (pid._pid == 0) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to kill 0");
  }

  // return the result
  v8::Handle<v8::Object> result = v8::Object::New(isolate);
  ExternalId external;
  external._pid = pid._pid;

  auto external_status = TRI_KillExternalProcess(pid, signal, isTerminating);

  convertStatusToV8(args, result, external_status, external);

  // return the result
  TRI_V8_RETURN(result);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief suspends an external process, only Unix
////////////////////////////////////////////////////////////////////////////////

static void JS_SuspendExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("suspendExternal(<external-identifier>)");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  ExternalId pid;

#ifndef _WIN32
  pid._pid = static_cast<TRI_pid_t>(TRI_ObjectToUInt64(isolate, args[0], true));
#else
  pid._pid = static_cast<DWORD>(TRI_ObjectToUInt64(isolate, args[0], true));
#endif

  // return the result
  if (TRI_SuspendExternalProcess(pid)) {
    TRI_V8_RETURN_TRUE();
  }
  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief continues an external process
////////////////////////////////////////////////////////////////////////////////

static void JS_ContinueExternal(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("continueExternal(<external-identifier>)");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToControlProcesses(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to execute or modify state of external processes");
  }

  ExternalId pid;

#ifndef _WIN32
  pid._pid = static_cast<TRI_pid_t>(TRI_ObjectToUInt64(isolate, args[0], true));
#else
  pid._pid = static_cast<DWORD>(TRI_ObjectToUInt64(isolate, args[0], true));
#endif

  // return the result
  if (TRI_ContinueExternalProcess(pid)) {
    TRI_V8_RETURN_TRUE();
  }
  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief checks if a port is available
////////////////////////////////////////////////////////////////////////////////

static void JS_TestPort(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("testPort(<address>)");
  }

  auto& server = application_features::ApplicationServer::server();
  V8SecurityFeature& v8security = server.getFeature<V8SecurityFeature>();

  if (!v8security.isAllowedToTestPorts(isolate)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_FORBIDDEN,
        "not allowed to test ports");
  }

  std::string address = TRI_ObjectToString(isolate, args[0]);
  Endpoint* endpoint = Endpoint::serverFactory(address, 10, false);
  if (nullptr == endpoint) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(
        TRI_ERROR_BAD_PARAMETER,
        "address description invalid, cannot create endpoint");
  }
  TRI_socket_t s = endpoint->connect(1, 1);
  bool available = TRI_isvalidsocket(s);

  if (available) {
    endpoint->disconnect();
  }

  delete endpoint;

  // return the result
  if (available) {
    TRI_V8_RETURN_TRUE();
  }

  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief checks if the application server is stopping
////////////////////////////////////////////////////////////////////////////////

static void JS_IsStopping(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("isStopping()");
  }

  auto& server = ApplicationServer::server();
  if (server.isStopping()) {
    TRI_V8_RETURN_TRUE();
  }

  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief returns keycode of currently pressed key
////////////////////////////////////////////////////////////////////////////////

static void JS_termsize(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the arguments
  if (args.Length() != 0) {
    TRI_V8_THROW_EXCEPTION_USAGE("termsize()");
  }

  TRI_TerminalSize s = TRI_DefaultTerminalSize();
  v8::Handle<v8::Array> list = v8::Array::New(isolate, 2);
  list->Set(0, v8::Integer::New(isolate, s.rows));
  list->Set(1, v8::Integer::New(isolate, s.columns));

  TRI_V8_RETURN(list);
  TRI_V8_TRY_CATCH_END
}

/// @brief convert a V8 value to VPack
static void JS_V8ToVPack(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the argument
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("V8_TO_VPACK(value)");
  }

  VPackBuilder builder;
  int res = TRI_V8ToVPack(isolate, builder, args[0], false);

  if (res != TRI_ERROR_NO_ERROR) {
    TRI_V8_THROW_EXCEPTION(res);
  }

  VPackSlice slice = builder.slice();

  V8Buffer* buffer =
      V8Buffer::New(isolate, slice.startAs<char const>(), slice.byteSize());
  v8::Local<v8::Object> bufferObject =
      v8::Local<v8::Object>::New(isolate, buffer->_handle);
  TRI_V8_RETURN(bufferObject);

  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

/// @brief convert a VPack value to V8
static void JS_VPackToV8(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  // extract the argument
  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("VPACK_TO_V8(value)");
  }

  VPackValidator validator;

  if (args[0]->IsString() || args[0]->IsStringObject()) {
    // supplied argument is a string
    std::string const value = TRI_ObjectToString(isolate, args[0]);

    validator.validate(value.c_str(), value.size(), false);

    VPackSlice slice(reinterpret_cast<uint8_t const*>(value.data()));
    v8::Handle<v8::Value> result = TRI_VPackToV8(isolate, slice);
    TRI_V8_RETURN(result);
  } else if (args[0]->IsObject() && V8Buffer::hasInstance(isolate, args[0])) {
    // argument is a buffer
    char const* data = V8Buffer::data(isolate, args[0].As<v8::Object>());
    size_t size = V8Buffer::length(isolate, args[0].As<v8::Object>());

    validator.validate(data, size, false);

    VPackSlice slice(reinterpret_cast<uint8_t const*>(data));
    v8::Handle<v8::Value> result = TRI_VPackToV8(isolate, slice);
    TRI_V8_RETURN(result);
  } else {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_BAD_PARAMETER,
                                   "invalid argument type for VPACK_TO_V8()");
  }

  TRI_V8_RETURN_FALSE();
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief ArangoError
////////////////////////////////////////////////////////////////////////////////

static void JS_ArangoError(v8::FunctionCallbackInfo<v8::Value> const& args) {
  v8::Isolate* isolate = args.GetIsolate();
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  TRI_GET_GLOBALS();
  TRI_GET_GLOBAL_STRING(ErrorKey);
  TRI_GET_GLOBAL_STRING(ErrorNumKey);

  v8::Handle<v8::Object> self =
      args.Holder()->ToObject(TRI_IGETC).FromMaybe(v8::Local<v8::Object>());

  self->Set(ErrorKey, v8::True(isolate));
  self->Set(ErrorNumKey, v8::Integer::New(isolate, TRI_ERROR_FAILED));

  if (0 < args.Length() && args[0]->IsObject()) {
    TRI_GET_GLOBAL_STRING(CodeKey);
    TRI_GET_GLOBAL_STRING(ErrorMessageKey);

    v8::Handle<v8::Object> data = TRI_ToObject(context, args[0]);

    if (TRI_HasProperty(context, isolate, data, ErrorKey)) {
      self->Set(ErrorKey, TRI_GetProperty(context, isolate, data, ErrorKey));
    }

    if (TRI_HasProperty(context, isolate, data, CodeKey)) {
      self->Set(CodeKey, TRI_GetProperty(context, isolate, data, CodeKey));
    }

    if (TRI_HasProperty(context, isolate, data, ErrorNumKey)) {
      self->Set(ErrorNumKey, TRI_GetProperty(context, isolate, data, ErrorNumKey));
    }

    if (TRI_HasProperty(context, isolate, data, ErrorMessageKey)) {
      self->Set(ErrorMessageKey, TRI_GetProperty(context, isolate, data, ErrorMessageKey));
    }
  }

  {
    // call Error.captureStackTrace(this) so the ArangoError object gets a nifty
    // stack trace
    v8::Handle<v8::Object> current = isolate->GetCurrentContext()->Global();
    v8::Handle<v8::Value> errorObject =
        TRI_GetProperty(context, isolate, current, "Error");
    v8::Handle<v8::Object> err = v8::Handle<v8::Object>::Cast(errorObject);
    v8::Handle<v8::Function> captureStackTrace = v8::Handle<v8::Function>::Cast(
        TRI_GetProperty(context, isolate, err, "captureStackTrace"));

    v8::Handle<v8::Value> arguments[] = {self};
    captureStackTrace->Call(current, 1, arguments);
  }

  TRI_V8_RETURN(self);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief isIP
////////////////////////////////////////////////////////////////////////////////

static void JS_IsIP(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1) {
    TRI_V8_THROW_EXCEPTION_USAGE("isIP(<value>)");
  }

  TRI_Utf8ValueNFC address(isolate, args[0]);

  if (TRI_InetPton4(*address, nullptr) == TRI_ERROR_NO_ERROR) {
    TRI_V8_RETURN(v8::Number::New(isolate, 4));
  } else if (TRI_InetPton6(*address, nullptr) == 0) {
    TRI_V8_RETURN(v8::Number::New(isolate, 6));
  } else {
    TRI_V8_RETURN(v8::Number::New(isolate, 0));
  }
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief SplitWordlist - splits words via the tokenizer
////////////////////////////////////////////////////////////////////////////////

static void JS_SplitWordlist(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if ((args.Length() < 2) || (args.Length() > 4)) {
    TRI_V8_THROW_EXCEPTION_USAGE(
        "SplitWordlist(<value>, minLength, [<maxLength>, [<lowerCase>]])");
  }

  std::string stringToTokenize = TRI_ObjectToString(isolate, args[0]);

  size_t minLength = static_cast<size_t>(TRI_ObjectToUInt64(isolate, args[1], true));

  size_t maxLength = 40;
  if (args.Length() > 2) {
    maxLength = static_cast<size_t>(TRI_ObjectToUInt64(isolate, args[2], true));
  }

  bool lowerCase = false;
  if (args.Length() > 3) {
    lowerCase = TRI_ObjectToBoolean(isolate, args[3]);
  }

  std::set<std::string> wordList;

  if (!Utf8Helper::DefaultUtf8Helper.tokenize(wordList, arangodb::velocypack::StringRef(stringToTokenize),
                                              minLength, maxLength, lowerCase)) {
    TRI_V8_THROW_EXCEPTION_MESSAGE(TRI_ERROR_INTERNAL, "SplitWordlist failed!");
  }

  v8::Handle<v8::Array> v8WordList =
      v8::Array::New(isolate, static_cast<int>(wordList.size()));

  uint32_t i = 0;
  for (std::string const& word : wordList) {
    v8::Handle<v8::String> oneWord = TRI_V8_STD_STRING(isolate, word);
    v8WordList->Set(i, oneWord);
    i++;
  }

  TRI_V8_RETURN(v8WordList);
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reports an exception
////////////////////////////////////////////////////////////////////////////////

std::string TRI_StringifyV8Exception(v8::Isolate* isolate, v8::TryCatch* tryCatch) {
  v8::HandleScope handle_scope(isolate);

  TRI_Utf8ValueNFC exception(isolate, tryCatch->Exception());
  char const* exceptionString = *exception;
  v8::Handle<v8::Message> message = tryCatch->Message();
  std::string result;

  // V8 didn't provide any extra information about this error; just print the
  // exception.
  if (message.IsEmpty()) {
    if (exceptionString == nullptr) {
      result = "JavaScript exception\n";
    } else {
      result = "JavaScript exception: " + std::string(exceptionString) + "\n";
    }
  } else {
    TRI_Utf8ValueNFC filename(isolate, message->GetScriptResourceName());
    char const* filenameString = *filename;
    int linenum = message->GetLineNumber(TRI_IGETC).FromMaybe(-1);
    int start = message->GetStartColumn(TRI_IGETC).FromMaybe(-2) + 1;
    int end = message->GetEndColumn(TRI_IGETC).FromMaybe(-1);

    if ((filenameString == nullptr) || (!strcmp(filenameString, TRI_V8_SHELL_COMMAND_NAME))) {
      if (exceptionString == nullptr) {
        result = "JavaScript exception\n";
      } else {
        result = "JavaScript exception: " + std::string(exceptionString) + "\n";
      }
    } else {
      if (exceptionString == nullptr) {
        result = "JavaScript exception in file '" + std::string(filenameString) +
                 "' at " + StringUtils::itoa(linenum) + "," +
                 StringUtils::itoa(start) + "\n";
      } else {
        result = "JavaScript exception in file '" + std::string(filenameString) +
                 "' at " + StringUtils::itoa(linenum) + "," +
                 StringUtils::itoa(start) + ": " + exceptionString + "\n";
      }
    }

    TRI_Utf8ValueNFC sourceline(isolate, message->GetSourceLine(TRI_IGETC).FromMaybe(
                                             v8::Local<v8::String>()));

    if (*sourceline) {
      std::string l = *sourceline;

      result += "!" + l + "\n";

      if (1 < start) {
        l = std::string(start - 1, ' ');
      } else {
        l = "";
      }

      // in fact, we observed start being greater than end sometimes...
      // this does not make sense and seems to be a bug in V8, but it happens
      // so we need to work around this
      if (end >= start) {
        l += std::string((size_t)(end - start + 1), '^');
      } else {
        l = "^";
      }

      result += "!" + l + "\n";
    }

    auto stacktraceV8 =
        tryCatch->StackTrace(TRI_IGETC).FromMaybe(v8::Local<v8::Value>());
    TRI_Utf8ValueNFC stacktrace(isolate, stacktraceV8);

    if (*stacktrace && stacktrace.length() > 0) {
      result += "stacktrace: " + std::string(*stacktrace) + "\n";
    }
  }

  return result;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief prints an exception and stacktrace
////////////////////////////////////////////////////////////////////////////////

void TRI_LogV8Exception(v8::Isolate* isolate, v8::TryCatch* tryCatch) {
  v8::HandleScope handle_scope(isolate);

  TRI_Utf8ValueNFC exception(isolate, tryCatch->Exception());
  char const* exceptionString = *exception;
  v8::Handle<v8::Message> message = tryCatch->Message();

  // V8 didn't provide any extra information about this error; just print the
  // exception.
  if (message.IsEmpty()) {
    if (exceptionString == nullptr) {
      LOG_TOPIC("49465", ERR, arangodb::Logger::FIXME)
          << "JavaScript exception";
    } else {
      LOG_TOPIC("7e60e", ERR, arangodb::Logger::FIXME)
          << "JavaScript exception: " << exceptionString;
    }
  } else {
    TRI_Utf8ValueNFC filename(isolate, message->GetScriptResourceName());
    char const* filenameString = *filename;
    // if ifdef is not used, the compiler will complain about linenum being
    // unused
    int linenum = message->GetLineNumber(TRI_IGETC).FromMaybe(-1);
    int start = message->GetStartColumn(TRI_IGETC).FromMaybe(-2) + 1;
    int end = message->GetEndColumn(TRI_IGETC).FromMaybe(-1);

    if (filenameString == nullptr) {
      if (exceptionString == nullptr) {
        LOG_TOPIC("27c91", ERR, arangodb::Logger::FIXME)
            << "JavaScript exception";
      } else {
        LOG_TOPIC("52220", ERR, arangodb::Logger::FIXME)
            << "JavaScript exception: " << exceptionString;
      }
    } else {
      if (exceptionString == nullptr) {
        LOG_TOPIC("b3488", ERR, arangodb::Logger::FIXME)
            << "JavaScript exception in file '" << filenameString << "' at "
            << linenum << "," << start;
      } else {
        LOG_TOPIC("8a210", ERR, arangodb::Logger::FIXME)
            << "JavaScript exception in file '" << filenameString << "' at "
            << linenum << "," << start << ": " << exceptionString;
      }
    }

    TRI_Utf8ValueNFC sourceline(isolate, message->GetSourceLine(TRI_IGETC).FromMaybe(
                                             v8::Local<v8::String>()));

    if (*sourceline) {
      std::string l = *sourceline;

      LOG_TOPIC("409ee", ERR, arangodb::Logger::FIXME) << "!" << l;

      if (1 < start) {
        l = std::string(start - 1, ' ');
      } else {
        l = "";
      }

      l += std::string((size_t)(end - start + 1), '^');

      LOG_TOPIC("cb0bd", ERR, arangodb::Logger::FIXME) << "!" << l;
    }
    auto stacktraceV8 =
      tryCatch->StackTrace(TRI_IGETC).FromMaybe(v8::Local<v8::Value>());
    TRI_Utf8ValueNFC stacktrace(isolate, stacktraceV8);

    if (*stacktrace && stacktrace.length() > 0) {
      LOG_TOPIC("cb0bf", DEBUG, arangodb::Logger::V8) << "!" <<
        "stacktrace: " + std::string(*stacktrace) + "\n";
    }

  }
}

////////////////////////////////////////////////////////////////////////////////
/// @brief reads a file into the current context
////////////////////////////////////////////////////////////////////////////////

bool TRI_ExecuteGlobalJavaScriptFile(v8::Isolate* isolate, char const* filename,
                                     bool stripShebang) {
  return LoadJavaScriptFile(isolate, filename, stripShebang, true, false);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes all files from a directory in a local context
////////////////////////////////////////////////////////////////////////////////

bool TRI_ExecuteLocalJavaScriptDirectory(v8::Isolate* isolate, char const* path) {
  return LoadJavaScriptDirectory(isolate, path, false, true, true);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief parses a file
////////////////////////////////////////////////////////////////////////////////

bool TRI_ParseJavaScriptFile(v8::Isolate* isolate, char const* filename, bool stripShebang) {
  return LoadJavaScriptFile(isolate, filename, stripShebang, false, false);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief executes a string within a V8 context, optionally print the result
////////////////////////////////////////////////////////////////////////////////

v8::Handle<v8::Value> TRI_ExecuteJavaScriptString(v8::Isolate* isolate,
                                                  v8::Handle<v8::Context> context,
                                                  v8::Handle<v8::String> const source,
                                                  v8::Handle<v8::String> const name,
                                                  bool printResult) {
  v8::EscapableHandleScope scope(isolate);

  v8::ScriptOrigin scriptOrigin(name);

  v8::Handle<v8::Value> result;
  v8::Handle<v8::Script> script =
      v8::Script::Compile(context, source, &scriptOrigin).FromMaybe(v8::Local<v8::Script>());

  // compilation failed, print errors that happened during compilation
  if (script.IsEmpty()) {
    return scope.Escape<v8::Value>(result);
  }

  // compilation succeeded, run the script
  result = script->Run(context).FromMaybe(v8::Local<v8::Value>());

  if (result.IsEmpty()) {
    return scope.Escape<v8::Value>(result);
  }

  // if all went well and the result wasn't undefined then print the returned
  // value
  if (printResult && !result->IsUndefined()) {
    v8::TryCatch tryCatch(isolate);

    v8::Handle<v8::String> printFuncName =
        TRI_V8_ASCII_STRING(isolate, "print");
    v8::Handle<v8::Function> print =
        v8::Handle<v8::Function>::Cast(context->Global()->Get(printFuncName));

    if (print->IsFunction()) {
      v8::Handle<v8::Value> arguments[] = {result};
      print->Call(print, 1, arguments);

      if (tryCatch.HasCaught()) {
        if (tryCatch.CanContinue()) {
          TRI_LogV8Exception(isolate, &tryCatch);
        } else {
          TRI_GET_GLOBALS();
          v8g->_canceled = true;
          return scope.Escape<v8::Value>(v8::Undefined(isolate));
        }
      }
    } else {
      LOG_TOPIC("837e5", ERR, arangodb::Logger::FIXME)
          << "no output function defined in Javascript context";
    }
  }

  return scope.Escape<v8::Value>(result);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief creates an error in a javascript object, based on error number only
////////////////////////////////////////////////////////////////////////////////

void TRI_CreateErrorObject(v8::Isolate* isolate, int errorNumber) {
  v8::HandleScope scope(isolate);
  CreateErrorObject(isolate, errorNumber, TRI_errno_string(errorNumber));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief creates an error in a javascript object, based on arangodb::result
////////////////////////////////////////////////////////////////////////////////
void TRI_CreateErrorObject(v8::Isolate* isolate, arangodb::Result const& res) {
  TRI_CreateErrorObject(isolate, res.errorNumber(), res.errorMessage(), false);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief creates an error in a javascript object
////////////////////////////////////////////////////////////////////////////////

void TRI_CreateErrorObject(v8::Isolate* isolate, int errorNumber,
                           std::string const& message, bool autoPrepend) {
  v8::HandleScope scope(isolate);

  try {
    // does string concatenation, so we must wrap this in a try...catch block
    if (autoPrepend && message.empty()) {
      CreateErrorObject(isolate, errorNumber,
                        message + ": " + std::string(TRI_errno_string(errorNumber)));
    } else {
      CreateErrorObject(isolate, errorNumber, message);
    }
  } catch (...) {
    // we cannot do anything about this here, but no C++ exception must
    // escape the C++ bindings called by V8
  }
}

////////////////////////////////////////////////////////////////////////////////
/// @brief normalizes a v8 object
////////////////////////////////////////////////////////////////////////////////

void TRI_normalize_V8_Obj(v8::FunctionCallbackInfo<v8::Value> const& args,
                          v8::Handle<v8::Value> obj) {
  v8::Isolate* isolate = args.GetIsolate();
  v8::Local<v8::Context> context = isolate->GetCurrentContext();
  v8::HandleScope scope(isolate);

  v8::String::Value str(isolate, TRI_ObjectToString(context, obj));
  size_t str_len = str.length();
  if (str_len > 0) {
    UErrorCode errorCode = U_ZERO_ERROR;
    icu::Normalizer2 const* normalizer =
        icu::Normalizer2::getInstance(nullptr, "nfc", UNORM2_COMPOSE, errorCode);

    if (U_FAILURE(errorCode)) {
      TRI_V8_RETURN(TRI_V8_PAIR_STRING(isolate, (char*)*str, (int)str_len));
    }

    icu::UnicodeString result =
        normalizer->normalize(icu::UnicodeString((UChar*)*str, (int32_t)str_len), errorCode);

    if (U_FAILURE(errorCode)) {
      TRI_V8_RETURN(TRI_V8_STRING_UTF16(isolate, *str, (int)str_len));
    }

    // ..........................................................................
    // Take note here: we are assuming that the ICU type UChar is two bytes.
    // There is no guarantee that this will be the case on all platforms and
    // compilers. v8 expects uint16_t (2 bytes)
    // ..........................................................................

    TRI_V8_RETURN(TRI_V8_STRING_UTF16(isolate, (uint16_t const*)result.getBuffer(),
                                      result.length()));
  }

  TRI_V8_RETURN(v8::String::Empty(isolate));
}

////////////////////////////////////////////////////////////////////////////////
/// @brief creates the path list
////////////////////////////////////////////////////////////////////////////////

v8::Handle<v8::Array> static V8PathList(v8::Isolate* isolate, std::string const& modules) {
  v8::EscapableHandleScope scope(isolate);

#ifdef _WIN32
  std::vector<std::string> paths = StringUtils::split(modules, ';');
#else
  std::vector<std::string> paths = StringUtils::split(modules, ";:");
#endif

  uint32_t const n = static_cast<uint32_t>(paths.size());
  v8::Handle<v8::Array> result = v8::Array::New(isolate, n);

  for (uint32_t i = 0; i < n; ++i) {
    result->Set(i, TRI_V8_STD_STRING(isolate, paths[i]));
  }

  return scope.Escape<v8::Array>(result);
}

////////////////////////////////////////////////////////////////////////////////
/// @brief execute a single garbage collection run
////////////////////////////////////////////////////////////////////////////////

static bool SingleRunGarbageCollectionV8(v8::Isolate* isolate, int idleTimeInMs) {
  isolate->LowMemoryNotification();
  bool rc = isolate->IdleNotificationDeadline(idleTimeInMs);
  isolate->RunMicrotasks();
  return rc;
}

////////////////////////////////////////////////////////////////////////////////
/// @brief run the V8 garbage collection for at most a specifiable amount of
/// time. returns a boolean indicating whether or not the caller should attempt
/// to do more gc
////////////////////////////////////////////////////////////////////////////////

bool TRI_RunGarbageCollectionV8(v8::Isolate* isolate, double availableTime) {
  int idleTimeInMs = 1000;

  if (availableTime >= 5.0) {
    idleTimeInMs = 5000;
  }
  if (availableTime >= 10.0) {
    idleTimeInMs = 10000;
  }

  try {
    TRI_ClearObjectCacheV8(isolate);

    double const until = TRI_microtime() + availableTime;

    int totalGcTimeInMs = static_cast<int>(availableTime) * 1000;
    int gcAttempts = totalGcTimeInMs / idleTimeInMs;

    if (gcAttempts <= 0) {
      // minimum is to run the GC once
      gcAttempts = 1;
    }

    int gcTries = 0;

    while (++gcTries <= gcAttempts) {
      if (SingleRunGarbageCollectionV8(isolate, idleTimeInMs)) {
        return false;
      }
    }

    size_t i = 0;
    while (TRI_microtime() < until) {
      if (++i % 1000 == 0) {
        // garbage collection only every x iterations, otherwise we'll use too
        // much CPU
        if (++gcTries > gcAttempts || SingleRunGarbageCollectionV8(isolate, idleTimeInMs)) {
          return false;
        }
      }

      std::this_thread::sleep_for(std::chrono::milliseconds(1));
    }

    return true;
  } catch (...) {
    // error caught during garbage collection
    return false;
  }
}

////////////////////////////////////////////////////////////////////////////////
/// @brief clear the instance-local cache of wrapped objects
////////////////////////////////////////////////////////////////////////////////

void TRI_ClearObjectCacheV8(v8::Isolate* isolate) {
  auto globals = isolate->GetCurrentContext()->Global();
  v8::Local<v8::Context> context = isolate->GetCurrentContext();

  if (TRI_HasProperty(context, isolate, globals, "__dbcache__")) {
    v8::Handle<v8::Object> cacheObject =
        TRI_GetProperty(context, isolate, globals, "__dbcache__")
            ->ToObject(TRI_IGETC)
            .FromMaybe(v8::Local<v8::Object>());
    if (!cacheObject.IsEmpty()) {
      v8::Handle<v8::Array> props = cacheObject->GetPropertyNames();
      for (uint32_t i = 0; i < props->Length(); i++) {
        v8::Handle<v8::Value> key = props->Get(i);
        cacheObject->Delete(TRI_IGETC, key).FromMaybe(false);  // Ignore errors.
      }
    }
  }
}

////////////////////////////////////////////////////////////////////////////////
/// @brief check if we are in the enterprise edition
////////////////////////////////////////////////////////////////////////////////

static void JS_IsEnterprise(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);
#ifndef USE_ENTERPRISE
  TRI_V8_RETURN(v8::False(isolate));
#else
  TRI_V8_RETURN(v8::True(isolate));
#endif
  TRI_V8_TRY_CATCH_END
}

////////////////////////////////////////////////////////////////////////////////
/// @brief convert errror number to httpCode
////////////////////////////////////////////////////////////////////////////////

static void JS_ErrorNumberToHttpCode(v8::FunctionCallbackInfo<v8::Value> const& args) {
  TRI_V8_TRY_CATCH_BEGIN(isolate);
  v8::HandleScope scope(isolate);

  if (args.Length() != 1 || ! args[0]->IsNumber()) {
    TRI_V8_THROW_EXCEPTION_USAGE("errorNumberToHttpCode(<int>)");
  }

  auto num = TRI_ObjectToInt64(isolate, args[0]);
  auto code = arangodb::GeneralResponse::responseCode(static_cast<int>(num));

  using Type = typename std::underlying_type<arangodb::rest::ResponseCode>::type;
  TRI_V8_RETURN_INTEGER(static_cast<Type>(code));
  TRI_V8_TRY_CATCH_END
}
////////////////////////////////////////////////////////////////////////////////
/// @brief stores the V8 utils functions inside the global variable
////////////////////////////////////////////////////////////////////////////////

extern void TRI_InitV8Env(v8::Isolate* isolate, v8::Handle<v8::Context> context);

void TRI_InitV8Utils(v8::Isolate* isolate, v8::Handle<v8::Context> context,
                     std::string const& startupPath, std::string const& modules) {
  v8::HandleScope scope(isolate);

  // check the isolate
  TRI_v8_global_t* v8g = TRI_GetV8Globals(isolate);
  TRI_ASSERT(v8g != nullptr);

  v8::Handle<v8::FunctionTemplate> ft;
  v8::Handle<v8::ObjectTemplate> rt;

  // .............................................................................
  // generate the general error template
  // .............................................................................

  ft = v8::FunctionTemplate::New(isolate, JS_ArangoError);
  ft->SetClassName(TRI_V8_ASCII_STRING(isolate, "ArangoError"));

  // ArangoError is a "sub-class" of Error
  v8::Handle<v8::Function> ArangoErrorFunc = ft->GetFunction();
  v8::Handle<v8::Value> ErrorObject =
      context->Global()->Get(TRI_V8_ASCII_STRING(isolate, "Error"));
  v8::Handle<v8::Value> ErrorPrototype =
      ErrorObject->ToObject(context)
          .FromMaybe(v8::Local<v8::Object>())
          ->Get(TRI_V8_ASCII_STRING(isolate, "prototype"));

  ArangoErrorFunc->Get(TRI_V8_ASCII_STRING(isolate, "prototype"))
      ->ToObject(context)
      .FromMaybe(v8::Local<v8::Object>())
      ->SetPrototype(context, ErrorPrototype)
      .FromMaybe(false);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "ArangoError"), ArangoErrorFunc);

  rt = ft->InstanceTemplate();
  v8g->ArangoErrorTempl.Reset(isolate, rt);

  // .............................................................................
  // create the global functions
  // .............................................................................

  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "FS_CHMOD"), JS_ChMod);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_EXISTS"), JS_Exists);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_FILESIZE"), JS_SizeFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_GET_TEMP_FILE"),
                               JS_GetTempFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_GET_TEMP_PATH"),
                               JS_GetTempPath);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_IS_DIRECTORY"),
                               JS_IsDirectory);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_IS_FILE"), JS_IsFile);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "FS_LIST"), JS_List);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_LIST_TREE"), JS_ListTree);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_MAKE_ABSOLUTE"),
                               JS_MakeAbsolute);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "FS_MAKE_DIRECTORY"), JS_MakeDirectory);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "FS_MAKE_DIRECTORY_RECURSIVE"),
      JS_MakeDirectoryRecursive);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "FS_MOVE"), JS_MoveFile);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "FS_COPY_RECURSIVE"), JS_CopyRecursive);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_COPY_FILE"), JS_CopyFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_LINK_FILE"), JS_LinkFile);

  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "FS_MTIME"), JS_MTime);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_REMOVE"), JS_Remove);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "FS_REMOVE_DIRECTORY"),
                               JS_RemoveDirectory);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "FS_REMOVE_RECURSIVE_DIRECTORY"),
      JS_RemoveRecursiveDirectory);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_UNZIP_FILE"), JS_UnzipFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_ZIP_FILE"), JS_ZipFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "FS_ADLER32"), JS_Adler32);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_APPEND"), JS_Append);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_BASE64DECODE"),
                               JS_Base64Decode);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_BASE64ENCODE"),
                               JS_Base64Encode);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_CHECK_AND_MARK_NONCE"), JS_MarkNonce);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_CREATE_NONCE"),
                               JS_CreateNonce);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_DOWNLOAD"), JS_Download);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_EXECUTE"), JS_Execute);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_EXECUTE_EXTERNAL"),
                               JS_ExecuteExternal);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_EXECUTE_EXTERNAL_AND_WAIT"),
      JS_ExecuteAndWaitExternal);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_GEN_RANDOM_ALPHA_NUMBERS"), JS_RandomAlphaNum);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_GEN_RANDOM_NUMBERS"),
                               JS_RandomNumbers);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_GEN_RANDOM_SALT"), JS_RandomSalt);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_GETLINE"), JS_Getline);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_HMAC"), JS_HMAC);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_IS_IP"), JS_IsIP);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_SPLIT_WORDS_ICU"), JS_SplitWordlist);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_PROCESS_STATISTICS_EXTERNAL"),
                               JS_ProcessStatisticsExternal);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_GET_EXTERNAL_SPAWNED"),
                               JS_GetExternalSpawned);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_KILL_EXTERNAL"), JS_KillExternal);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_SUSPEND_EXTERNAL"),
                               JS_SuspendExternal);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_CONTINUE_EXTERNAL"),
                               JS_ContinueExternal);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_STATUS_EXTERNAL"), JS_StatusExternal);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_LOAD"), JS_Load);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_LOG"), JS_Log);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_LOG_LEVEL"), JS_LogLevel);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_MD5"), JS_Md5);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_OPTIONS"), JS_Options);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_OUTPUT"), JS_Output);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_POLLSTDIN"), JS_PollStdin);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_PARSE"), JS_Parse);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_PARSE_FILE"), JS_ParseFile);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_PBKDF2HS1"), JS_PBKDF2HS1);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_PBKDF2"), JS_PBKDF2);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_PROCESS_STATISTICS"),
                               JS_ProcessStatisticsSelf);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_GET_PID"), JS_GetPid);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_RAND"), JS_Rand);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_READ"), JS_Read);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_READ64"), JS_Read64);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_READ_BUFFER"),
                               JS_ReadBuffer);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_READ_GZIP"),
                               JS_ReadGzip);
#ifdef USE_ENTERPRISE
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_READ_DECRYPT"),
                               JS_ReadDecrypt);
#endif
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_SHA1"), JS_Sha1);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SHA224"), JS_Sha224);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SHA256"), JS_Sha256);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SHA384"), JS_Sha384);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SHA512"), JS_Sha512);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SLEEP"), JS_Sleep);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_SPRINTF"), JS_SPrintF);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_TEST_PORT"), JS_TestPort);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_TIME"), JS_Time);
  TRI_AddGlobalFunctionVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "SYS_WAIT"), JS_Wait);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_WRITE"), JS_Write);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate,
                                                   "SYS_DEBUG_CAN_USE_FAILAT"),
                               JS_DebugCanUseFailAt);
  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_IS_STOPPING"),
                               JS_IsStopping);
  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_TERMINAL_SIZE"), JS_termsize);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "V8_TO_VPACK"), JS_V8ToVPack);

  TRI_AddGlobalFunctionVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "VPACK_TO_V8"), JS_VPackToV8);

  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_IS_ENTERPRISE"), JS_IsEnterprise);

  TRI_AddGlobalFunctionVocbase(
      isolate, TRI_V8_ASCII_STRING(isolate, "SYS_ERROR_NUMBER_TO_HTTP_CODE"), JS_ErrorNumberToHttpCode);
  // .............................................................................
  // create the global variables
  // .............................................................................

  TRI_AddGlobalVariableVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "HOME"),
                               TRI_V8_STD_STRING(isolate, FileUtils::homeDirectory()));

  TRI_AddGlobalVariableVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "MODULES_PATH"),
                               V8PathList(isolate, modules));

  TRI_AddGlobalVariableVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "STARTUP_PATH"),
                               TRI_V8_STD_STRING(isolate, startupPath));

  TRI_AddGlobalVariableVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "PATH_SEPARATOR"),
                               TRI_V8_ASCII_STRING(isolate, TRI_DIR_SEPARATOR_STR));

#ifdef COVERAGE
  TRI_AddGlobalVariableVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "COVERAGE"),
                               v8::True(isolate));
#else
  TRI_AddGlobalVariableVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "COVERAGE"),
                               v8::False(isolate));
#endif

  TRI_AddGlobalVariableVocbase(isolate, TRI_V8_ASCII_STRING(isolate, "VERSION"),
                               TRI_V8_ASCII_STRING(isolate, ARANGODB_VERSION));

  TRI_AddGlobalVariableVocbase(isolate,
                               TRI_V8_ASCII_STRING(isolate, "SYS_PLATFORM"),
                               TRI_V8_ASCII_STRING(isolate, TRI_PLATFORM));

  TRI_InitV8Env(isolate, context);
}