Initial commit
This commit is contained in:
commit
f47e08fdcb
2409 files changed
+363607
No files matched your search
+1
@@ -0,0 +1 @@
|
||||
repo_token: 47iIZ0B3llo2Wc4dxWRltvgdImqcrVDTi
|
||||
+30
@@ -0,0 +1,30 @@
|
||||
{
|
||||
"extends": [
|
||||
"eslint:recommended"
|
||||
],
|
||||
"env": {
|
||||
"node": true,
|
||||
"mocha": true,
|
||||
"es6": true
|
||||
},
|
||||
"globals": {
|
||||
"Promise": true
|
||||
},
|
||||
"parserOptions": {
|
||||
"ecmaVersion": 2017
|
||||
},
|
||||
"plugins": [
|
||||
"prettier"
|
||||
],
|
||||
"rules": {
|
||||
"prettier/prettier": ["error", {
|
||||
"singleQuote": true,
|
||||
"tabWidth": 2,
|
||||
"printWidth": 100
|
||||
}],
|
||||
|
||||
"no-console": 0,
|
||||
"eqeqeq": ["error", "always", {"null": "ignore"}],
|
||||
"strict": ["error", "global"]
|
||||
}
|
||||
}
|
||||
+677
@@ -0,0 +1,677 @@
|
||||
# When a task that used to pass starts to fail
|
||||
# Go through all versions that may have been skipped to detect
|
||||
# when the task started failing
|
||||
stepback: true
|
||||
|
||||
# Mark a failure as a system/bootstrap failure (purple box) rather then a task
|
||||
# failure by default.
|
||||
# Actual testing tasks are marked with `type: test`
|
||||
command_type: system
|
||||
|
||||
# Protect ourself against rogue test case, or curl gone wild, that runs forever
|
||||
# Good rule of thumb: the averageish length a task takes, times 5
|
||||
# That roughly accounts for variable system performance for various buildvariants
|
||||
exec_timeout_secs: 1800 # 6 minutes is the longest we'll ever run
|
||||
|
||||
# What to do when evergreen hits the timeout (`post:` tasks are run automatically)
|
||||
timeout:
|
||||
- command: shell.exec
|
||||
params:
|
||||
script: |
|
||||
ls -la
|
||||
|
||||
functions:
|
||||
"fetch source":
|
||||
# Executes git clone and applies the submitted patch, if any
|
||||
- command: git.get_project
|
||||
params:
|
||||
directory: "src"
|
||||
# Applies the submitted patch, if any
|
||||
# Deprecated. Should be removed. But still needed for certain agents (ZAP)
|
||||
- command: git.apply_patch
|
||||
# Make an evergreen exapanstion file with dynamic values
|
||||
- command: shell.exec
|
||||
params:
|
||||
working_dir: "src"
|
||||
script: |
|
||||
# Get the current unique version of this checkout
|
||||
if [ "${is_patch}" = "true" ]; then
|
||||
CURRENT_VERSION=$(git describe)-patch-${version_id}
|
||||
else
|
||||
CURRENT_VERSION=latest
|
||||
fi
|
||||
|
||||
export DRIVERS_TOOLS="$(pwd)/../drivers-tools"
|
||||
export PROJECT_DIRECTORY="$(pwd)"
|
||||
export MONGODB_BINARIES="$DRIVERS_TOOLS/mongodb/bin"
|
||||
export UPLOAD_BUCKET="${project}"
|
||||
|
||||
cat <<EOT > expansion.yml
|
||||
CURRENT_VERSION: "$CURRENT_VERSION"
|
||||
DRIVERS_TOOLS: "$DRIVERS_TOOLS"
|
||||
MONGO_ORCHESTRATION_HOME: "$MONGO_ORCHESTRATION_HOME"
|
||||
MONGODB_BINARIES: "$MONGODB_BINARIES"
|
||||
UPLOAD_BUCKET: "$UPLOAD_BUCKET"
|
||||
PROJECT_DIRECTORY: "$PROJECT_DIRECTORY"
|
||||
PREPARE_SHELL: |
|
||||
set -o errexit
|
||||
set -o xtrace
|
||||
export DRIVERS_TOOLS="$DRIVERS_TOOLS"
|
||||
export MONGO_ORCHESTRATION_HOME="$MONGO_ORCHESTRATION_HOME"
|
||||
export MONGODB_BINARIES="$MONGODB_BINARIES"
|
||||
export UPLOAD_BUCKET="$UPLOAD_BUCKET"
|
||||
export PROJECT_DIRECTORY="$PROJECT_DIRECTORY"
|
||||
|
||||
export TMPDIR="$MONGO_ORCHESTRATION_HOME/db"
|
||||
export PATH="$MONGODB_BINARIES:$PATH"
|
||||
export PROJECT="${project}"
|
||||
EOT
|
||||
# See what we've done
|
||||
cat expansion.yml
|
||||
|
||||
# Load the expansion file to make an evergreen variable with the current unique version
|
||||
- command: expansions.update
|
||||
params:
|
||||
file: src/expansion.yml
|
||||
|
||||
"prepare resources":
|
||||
- command: shell.exec
|
||||
params:
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
rm -rf $DRIVERS_TOOLS
|
||||
git clone git://github.com/mongodb-labs/drivers-evergreen-tools.git $DRIVERS_TOOLS
|
||||
|
||||
"run tests":
|
||||
- command: shell.exec
|
||||
type: test
|
||||
params:
|
||||
working_dir: "src"
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
MONGODB_VERSION=${VERSION} TOPOLOGY=${TOPOLOGY} AUTH=${AUTH} SSL=${SSL} MONGODB_URI="${MONGODB_URI}" sh ${PROJECT_DIRECTORY}/.evergreen/run-tests.sh
|
||||
|
||||
"cleanup":
|
||||
- command: shell.exec
|
||||
params:
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
rm -rf $DRIVERS_TOOLS || true
|
||||
|
||||
"fix absolute paths":
|
||||
- command: shell.exec
|
||||
params:
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
for filename in $(find ${DRIVERS_TOOLS} -name \*.json); do
|
||||
perl -p -i -e "s|ABSOLUTE_PATH_REPLACEMENT_TOKEN|${DRIVERS_TOOLS}|g" $filename
|
||||
done
|
||||
|
||||
# "windows fix":
|
||||
# - command: shell.exec
|
||||
# params:
|
||||
# script: |
|
||||
# ${PREPARE_SHELL}
|
||||
# for i in $(find ${DRIVERS_TOOLS}/.evergreen ${PROJECT_DIRECTORY}/.evergreen -name \*.sh); do
|
||||
# cat $i | tr -d '\r' > $i.new
|
||||
# mv $i.new $i
|
||||
# done
|
||||
# # Copy client certificate because symlinks do not work on Windows.
|
||||
# cp ${DRIVERS_TOOLS}/.evergreen/x509gen/client.pem ${MONGO_ORCHESTRATION_HOME}/lib/client.pem
|
||||
|
||||
"make files executable":
|
||||
- command: shell.exec
|
||||
params:
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
for i in $(find ${DRIVERS_TOOLS}/.evergreen ${PROJECT_DIRECTORY}/.evergreen -name \*.sh); do
|
||||
chmod +x $i
|
||||
done
|
||||
|
||||
"install dependencies":
|
||||
- command: shell.exec
|
||||
params:
|
||||
working_dir: "src"
|
||||
script: |
|
||||
${PREPARE_SHELL}
|
||||
NODE_LTS_NAME=${NODE_LTS_NAME} sh ${PROJECT_DIRECTORY}/.evergreen/install-dependencies.sh
|
||||
|
||||
"run atlas tests":
|
||||
- command: shell.exec
|
||||
params:
|
||||
working_dir: "src"
|
||||
silent: true
|
||||
script: |
|
||||
# DO NOT ECHO WITH XTRACE (which PREPARE_SHELL does)
|
||||
NODE_LTS_NAME='${NODE_LTS_NAME}' ATLAS_REPL='${atlas_repl}' ATLAS_SHRD='${atlas_shrd}' ATLAS_FREE='${atlas_free}' ATLAS_TLS11='${atlas_tls11}' ATLAS_TLS12='${atlas_tls12}' sh ${PROJECT_DIRECTORY}/.evergreen/run-atlas-tests.sh
|
||||
|
||||
pre:
|
||||
- func: "fetch source"
|
||||
- func: "prepare resources"
|
||||
# - func: "windows fix"
|
||||
- func: "fix absolute paths"
|
||||
- func: "make files executable"
|
||||
- func: "install dependencies"
|
||||
|
||||
post:
|
||||
- func: "cleanup"
|
||||
|
||||
tasks:
|
||||
# Standard test tasks {{{
|
||||
- name: "test-2.6-standalone"
|
||||
tags: ["2.6", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "2.6"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-2.6-replica_set"
|
||||
tags: ["2.6", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "2.6"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-2.6-sharded_cluster"
|
||||
tags: ["2.6", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "2.6"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-3.0-standalone"
|
||||
tags: ["3.0", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.0"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-3.0-replica_set"
|
||||
tags: ["3.0", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.0"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-3.0-sharded_cluster"
|
||||
tags: ["3.0", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.0"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-3.2-standalone"
|
||||
tags: ["3.2", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.2"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-3.2-replica_set"
|
||||
tags: ["3.2", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.2"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-3.2-sharded_cluster"
|
||||
tags: ["3.2", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.2"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-3.4-standalone"
|
||||
tags: ["3.4", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.4"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-3.4-replica_set"
|
||||
tags: ["3.4", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.4"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-3.4-sharded_cluster"
|
||||
tags: ["3.4", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.4"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-3.6-standalone"
|
||||
tags: ["3.6", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.6"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-3.6-replica_set"
|
||||
tags: ["3.6", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.6"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-3.6-sharded_cluster"
|
||||
tags: ["3.6", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "3.6"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-4.0-standalone"
|
||||
tags: ["4.0", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "4.0"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-4.0-replica_set"
|
||||
tags: ["4.0", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "4.0"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-4.0-sharded_cluster"
|
||||
tags: ["4.0", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "4.0"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "test-latest-standalone"
|
||||
tags: ["latest", "standalone"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "latest"
|
||||
TOPOLOGY: "server"
|
||||
|
||||
- name: "test-latest-replica_set"
|
||||
tags: ["latest", "replica_set"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "latest"
|
||||
TOPOLOGY: "replica_set"
|
||||
|
||||
- name: "test-latest-sharded_cluster"
|
||||
tags: ["latest", "sharded_cluster"]
|
||||
commands:
|
||||
- func: "run tests"
|
||||
vars:
|
||||
VERSION: "latest"
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
|
||||
- name: "atlas-connect"
|
||||
tags: ["atlas-connect"]
|
||||
commands:
|
||||
- func: "run atlas tests"
|
||||
|
||||
# }}}
|
||||
|
||||
axes:
|
||||
- id: versions
|
||||
display_name: MongoDB Version
|
||||
values:
|
||||
- id: "latest"
|
||||
display_name: "latest"
|
||||
variables:
|
||||
VERSION: "latest"
|
||||
- id: "4.0"
|
||||
display_name: "4.0"
|
||||
variables:
|
||||
VERSION: "4.0"
|
||||
- id: "3.6"
|
||||
display_name: "3.6"
|
||||
variables:
|
||||
VERSION: "3.6"
|
||||
- id: "3.4"
|
||||
display_name: "3.4"
|
||||
variables:
|
||||
VERSION: "3.4"
|
||||
- id: "3.2"
|
||||
display_name: "3.2"
|
||||
variables:
|
||||
VERSION: "3.2"
|
||||
- id: "3.0"
|
||||
display_name: "3.0"
|
||||
variables:
|
||||
VERSION: "3.0"
|
||||
- id: "2.6"
|
||||
display_name: "2.6"
|
||||
variables:
|
||||
VERSION: "2.6"
|
||||
|
||||
- id: node-version
|
||||
display_name: "Node.js Version"
|
||||
values:
|
||||
- id: "Argon"
|
||||
display_name: "Node.js Argon"
|
||||
variables:
|
||||
NODE_LTS_NAME: "argon"
|
||||
- id: "Boron"
|
||||
display_name: "Node.js Boron"
|
||||
variables:
|
||||
NODE_LTS_NAME: "boron"
|
||||
- id: "Carbon"
|
||||
display_name: "Node.js Carbon"
|
||||
variables:
|
||||
NODE_LTS_NAME: "carbon"
|
||||
|
||||
# OSes that support versions of MongoDB>=2.6 with SSL.
|
||||
- id: os-fully-featured
|
||||
display_name: OS
|
||||
values:
|
||||
- id: linux-64-amzn-test
|
||||
display_name: "Amazon Linux (Enterprise)"
|
||||
run_on: linux-64-amzn-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: ubuntu-14.04
|
||||
display_name: "Ubuntu 14.04"
|
||||
run_on: ubuntu1404-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: rhel70
|
||||
display_name: "RHEL 7.0"
|
||||
run_on: rhel70-small
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: debian71-test
|
||||
display_name: "Debian 7.1"
|
||||
run_on: debian71-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
# OSes that support versions of MongoDB without SSL.
|
||||
- id: os-nossl
|
||||
display_name: OS
|
||||
values:
|
||||
- id: archlinux-test
|
||||
display_name: "Archlinux"
|
||||
run_on: archlinux-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: macos-1012
|
||||
display_name: "macOS 10.12"
|
||||
run_on: macos-1012
|
||||
|
||||
# OSes that support versions of MongoDB>=3.2 with SSL.
|
||||
- id: os-requires-32
|
||||
display_name: OS
|
||||
values:
|
||||
- id: ubuntu-16.04
|
||||
display_name: "Ubuntu 16.04"
|
||||
run_on: ubuntu1604-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: suse12-x86-64-test
|
||||
display_name: "SUSE 12 (x86_64)"
|
||||
run_on: suse12-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: rhel71-power8-test
|
||||
display_name: "RHEL 7.1 (POWER8)"
|
||||
run_on: rhel71-power8-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
# OSes that introduced support for SSL with MongoDB>=3.2.
|
||||
- id: os-ssl-requires-32
|
||||
display_name: OS
|
||||
values:
|
||||
- id: macos-1012
|
||||
display_name: "macOS 10.12"
|
||||
run_on: macos-1012
|
||||
|
||||
# OSes that support versions of MongoDB>=3.4 with SSL.
|
||||
- id: os-requires-34
|
||||
display_name: OS
|
||||
values:
|
||||
- id: debian81-test
|
||||
display_name: "Debian 8.1"
|
||||
run_on: debian81-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
# NOTE: reenable when these are actually running 7.2, or we release a 7.4 rpm
|
||||
# - id: rhel72-zseries-test
|
||||
# display_name: "RHEL 7.2 (zSeries)"
|
||||
# run_on: rhel72-zseries-test
|
||||
# batchtime: 10080 # 7 days
|
||||
|
||||
- id: suse12-zseries-test
|
||||
display_name: "SUSE 12 (zSeries)"
|
||||
run_on: suse12-zseries-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: ubuntu1604-arm64-small
|
||||
display_name: "Ubuntu 16.04 (ARM64)"
|
||||
run_on: ubuntu1604-arm64-small
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: ubuntu1604-power8-test
|
||||
display_name: "Ubuntu 16.04 (POWER8)"
|
||||
run_on: ubuntu1604-power8-test
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
- id: ubuntu1604-zseries-small
|
||||
display_name: "Ubuntu 16.04 (zSeries)"
|
||||
run_on: ubuntu1604-zseries-small
|
||||
batchtime: 10080 # 7 days
|
||||
|
||||
# NOTE: reenable this when nvm supports windows, or we settle on an alternative tool
|
||||
# - id: os-windows
|
||||
# display_name: OS
|
||||
# values:
|
||||
# - id: windows-64-vs2010-test
|
||||
# display_name: "Windows (VS2010)"
|
||||
# run_on: windows-64-vs2010-test
|
||||
|
||||
# - id: windows-64-vs2013-test
|
||||
# display_name: "Windows (VS2013)"
|
||||
# run_on: windows-64-vs2013-test
|
||||
|
||||
# - id: windows-64-vs2015-test
|
||||
# display_name: "Windows (VS2015)"
|
||||
# run_on: windows-64-vs2015-test
|
||||
|
||||
|
||||
- id: topology
|
||||
display_name: Topology
|
||||
values:
|
||||
- id: standalone
|
||||
display_name: Standalone
|
||||
variables:
|
||||
TOPOLOGY: "server"
|
||||
- id: replicaset
|
||||
display_name: Replica Set
|
||||
variables:
|
||||
TOPOLOGY: "replica_set"
|
||||
- id: sharded-cluster
|
||||
display_name: Sharded Cluster
|
||||
variables:
|
||||
TOPOLOGY: "sharded_cluster"
|
||||
- id: auth
|
||||
display_name: Authentication
|
||||
values:
|
||||
- id: auth
|
||||
display_name: Auth
|
||||
variables:
|
||||
AUTH: "auth"
|
||||
- id: noauth
|
||||
display_name: NoAuth
|
||||
variables:
|
||||
AUTH: "noauth"
|
||||
- id: ssl
|
||||
display_name: SSL
|
||||
values:
|
||||
- id: ssl
|
||||
display_name: SSL
|
||||
variables:
|
||||
SSL: "ssl"
|
||||
- id: nossl
|
||||
display_name: NoSSL
|
||||
variables:
|
||||
SSL: "nossl"
|
||||
- id: storage-engine
|
||||
display_name: Storage
|
||||
values:
|
||||
- id: mmapv1
|
||||
display_name: MMAPv1
|
||||
variables:
|
||||
STORAGE_ENGINE: "mmapv1"
|
||||
- id: wiredtiger
|
||||
display_name: WiredTiger
|
||||
variables:
|
||||
STORAGE_ENGINE: "wiredtiger"
|
||||
- id: inmemory
|
||||
display_name: InMemory
|
||||
variables:
|
||||
STORAGE_ENGINE: "inmemory"
|
||||
|
||||
|
||||
buildvariants:
|
||||
- matrix_name: "tests-all"
|
||||
matrix_spec: {"os-fully-featured": "*", node-version: "*" } # auth: "*", ssl: "*",
|
||||
display_name: "${node-version} ${os-fully-featured} ${auth} ${ssl}"
|
||||
tasks:
|
||||
- name: "test-latest-replica_set"
|
||||
- name: "test-latest-sharded_cluster"
|
||||
- name: "test-latest-standalone"
|
||||
- name: "test-3.6-replica_set"
|
||||
- name: "test-3.6-sharded_cluster"
|
||||
- name: "test-3.6-standalone"
|
||||
- name: "test-3.4-replica_set"
|
||||
- name: "test-3.4-sharded_cluster"
|
||||
- name: "test-3.4-standalone"
|
||||
- name: "test-3.2-replica_set"
|
||||
- name: "test-3.2-sharded_cluster"
|
||||
- name: "test-3.2-standalone"
|
||||
- name: "test-3.0-replica_set"
|
||||
- name: "test-3.0-sharded_cluster"
|
||||
- name: "test-3.0-standalone"
|
||||
- name: "test-2.6-replica_set"
|
||||
- name: "test-2.6-sharded_cluster"
|
||||
- name: "test-2.6-standalone"
|
||||
|
||||
# - matrix_name: "tests-nossl"
|
||||
# matrix_spec: {"os-nossl": "*", auth: "*", ssl: "nossl", node-version: "*" }
|
||||
# display_name: "${node-version} ${os-nossl} ${auth} ${ssl}"
|
||||
# tasks:
|
||||
# - name: "test-latest-replica_set"
|
||||
# - name: "test-latest-sharded_cluster"
|
||||
# - name: "test-latest-standalone"
|
||||
# - name: "test-3.6-replica_set"
|
||||
# - name: "test-3.6-sharded_cluster"
|
||||
# - name: "test-3.6-standalone"
|
||||
# - name: "test-3.4-replica_set"
|
||||
# - name: "test-3.4-sharded_cluster"
|
||||
# - name: "test-3.4-standalone"
|
||||
# - name: "test-3.2-replica_set"
|
||||
# - name: "test-3.2-sharded_cluster"
|
||||
# - name: "test-3.2-standalone"
|
||||
# - name: "test-3.0-replica_set"
|
||||
# - name: "test-3.0-sharded_cluster"
|
||||
# - name: "test-3.0-standalone"
|
||||
# - name: "test-2.6-replica_set"
|
||||
# - name: "test-2.6-sharded_cluster"
|
||||
# - name: "test-2.6-standalone"
|
||||
|
||||
- matrix_name: "tests-os-requires-32"
|
||||
matrix_spec: {"os-requires-32": "*", node-version: "*" } # auth: "*", ssl: "*",
|
||||
display_name: "${node-version} ${os-requires-32} ${auth} ${ssl}"
|
||||
tasks:
|
||||
- name: "test-latest-replica_set"
|
||||
- name: "test-latest-sharded_cluster"
|
||||
- name: "test-latest-standalone"
|
||||
- name: "test-3.6-replica_set"
|
||||
- name: "test-3.6-sharded_cluster"
|
||||
- name: "test-3.6-standalone"
|
||||
- name: "test-3.4-replica_set"
|
||||
- name: "test-3.4-sharded_cluster"
|
||||
- name: "test-3.4-standalone"
|
||||
- name: "test-3.2-replica_set"
|
||||
- name: "test-3.2-sharded_cluster"
|
||||
- name: "test-3.2-standalone"
|
||||
|
||||
# - matrix_name: "tests-ssl-requires-32"
|
||||
# matrix_spec: {"os-ssl-requires-32": "*", auth: "*", ssl: "ssl", node-version: "*" }
|
||||
# display_name: "${node-version} ${os-ssl-requires-32} ${auth} ${ssl}"
|
||||
# tasks:
|
||||
# - name: "test-latest-replica_set"
|
||||
# - name: "test-latest-sharded_cluster"
|
||||
# - name: "test-latest-standalone"
|
||||
# - name: "test-3.6-replica_set"
|
||||
# - name: "test-3.6-sharded_cluster"
|
||||
# - name: "test-3.6-standalone"
|
||||
# - name: "test-3.4-replica_set"
|
||||
# - name: "test-3.4-sharded_cluster"
|
||||
# - name: "test-3.4-standalone"
|
||||
# - name: "test-3.2-replica_set"
|
||||
# - name: "test-3.2-sharded_cluster"
|
||||
# - name: "test-3.2-standalone"
|
||||
|
||||
- matrix_name: "tests-os-requires-34"
|
||||
matrix_spec: {"os-requires-34": "*", node-version: ["Boron", "Carbon"]} # auth: "*", ssl: "*",
|
||||
display_name: "${node-version} ${os-requires-34} ${auth} ${ssl}"
|
||||
tasks:
|
||||
- name: "test-latest-replica_set"
|
||||
- name: "test-latest-sharded_cluster"
|
||||
- name: "test-latest-standalone"
|
||||
- name: "test-3.6-replica_set"
|
||||
- name: "test-3.6-sharded_cluster"
|
||||
- name: "test-3.6-standalone"
|
||||
- name: "test-3.4-replica_set"
|
||||
- name: "test-3.4-sharded_cluster"
|
||||
- name: "test-3.4-standalone"
|
||||
|
||||
- matrix_name: "test-atlas-connect"
|
||||
matrix_spec: { node-version: "*", "os-fully-featured": "*" }
|
||||
display_name: "${node-version} ${os-fully-featured} atlas connect"
|
||||
tasks:
|
||||
- name: "atlas-connect"
|
||||
|
||||
# - matrix_name: "tests-windows"
|
||||
# matrix_spec: {os-windows: "*", node-version: "*" } # ssl: "*", auth: "*"
|
||||
# display_name: "${node-version} ${os-windows} ${auth} ${ssl}"
|
||||
# tasks:
|
||||
# - name: "test-latest-replica_set"
|
||||
# - name: "test-latest-sharded_cluster"
|
||||
# - name: "test-latest-standalone"
|
||||
# - name: "test-3.6-replica_set"
|
||||
# - name: "test-3.6-sharded_cluster"
|
||||
# - name: "test-3.6-standalone"
|
||||
# - name: "test-3.4-replica_set"
|
||||
# - name: "test-3.4-sharded_cluster"
|
||||
# - name: "test-3.4-standalone"
|
||||
# - name: "test-3.2-replica_set"
|
||||
# - name: "test-3.2-sharded_cluster"
|
||||
# - name: "test-3.2-standalone"
|
||||
# - name: "test-3.0-replica_set"
|
||||
# - name: "test-3.0-sharded_cluster"
|
||||
# - name: "test-3.0-standalone"
|
||||
# - name: "test-2.6-replica_set"
|
||||
# - name: "test-2.6-sharded_cluster"
|
||||
# - name: "test-2.6-standalone"
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
#!/bin/sh
|
||||
# set -o xtrace # Write all commands first to stderr
|
||||
set -o errexit # Exit the script with error if any of the commands fail
|
||||
|
||||
NODE_LTS_NAME=${NODE_LTS_NAME:-carbon}
|
||||
NODE_ARTIFACTS_PATH="${PROJECT_DIRECTORY}/node-artifacts"
|
||||
NPM_CACHE_DIR="${NODE_ARTIFACTS_PATH}/npm"
|
||||
NPM_TMP_DIR="${NODE_ARTIFATS_PATH}/tmp"
|
||||
|
||||
# this needs to be explicitly exported for the nvm install below
|
||||
export NVM_DIR="${NODE_ARTIFACTS_PATH}/nvm"
|
||||
|
||||
# create node artifacts path if needed
|
||||
mkdir -p ${NODE_ARTIFACTS_PATH}
|
||||
mkdir -p ${NPM_CACHE_DIR}
|
||||
mkdir -p "${NPM_TMP_DIR}"
|
||||
|
||||
# install Node.js
|
||||
curl -o- https://raw.githubusercontent.com/creationix/nvm/v0.33.8/install.sh | bash
|
||||
[ -s "${NVM_DIR}/nvm.sh" ] && \. "${NVM_DIR}/nvm.sh"
|
||||
nvm install --lts=${NODE_LTS_NAME}
|
||||
|
||||
# setup npm cache in a local directory
|
||||
cat <<EOT > .npmrc
|
||||
devdir=${NPM_CACHE_DIR}/.node-gyp
|
||||
init-module=${NPM_CACHE_DIR}/.npm-init.js
|
||||
cache=${NPM_CACHE_DIR}
|
||||
tmp=${NPM_TMP_DIR}
|
||||
EOT
|
||||
|
||||
# install node dependencies
|
||||
npm install
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
#!/bin/sh
|
||||
|
||||
set -o errexit # Exit the script with error if any of the commands fail
|
||||
|
||||
export PROJECT_DIRECTORY="$(pwd)"
|
||||
NODE_ARTIFACTS_PATH="${PROJECT_DIRECTORY}/node-artifacts"
|
||||
export NVM_DIR="${NODE_ARTIFACTS_PATH}/nvm"
|
||||
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
|
||||
|
||||
ATLAS_REPL="$ATLAS_REPL" ATLAS_SHRD="$ATLAS_SHRD" ATLAS_FREE="$ATLAS_FREE" ATLAS_TLS11="$ATLAS_TLS11" ATLAS_TLS12="$ATLAS_TLS12" npm run atlas
|
||||
+36
@@ -0,0 +1,36 @@
|
||||
#!/bin/sh
|
||||
# set -o xtrace # Write all commands first to stderr
|
||||
set -o errexit # Exit the script with error if any of the commands fail
|
||||
|
||||
# Supported/used environment variables:
|
||||
# AUTH Set to enable authentication. Defaults to "noauth"
|
||||
# SSL Set to enable SSL. Defaults to "nossl"
|
||||
# MONGODB_URI Set the suggested connection MONGODB_URI (including credentials and topology info)
|
||||
# MARCH Machine Architecture. Defaults to lowercase uname -m
|
||||
|
||||
AUTH=${AUTH:-noauth}
|
||||
SSL=${SSL:-nossl}
|
||||
MONGODB_URI=${MONGODB_URI:-}
|
||||
DRIVERS_TOOLS=${DRIVERS_TOOLS:-}
|
||||
MONGODB_VERSION=${MONGODB_VERSION:-}
|
||||
|
||||
# install MongoDB
|
||||
# Functions to fetch MongoDB binaries
|
||||
. ${DRIVERS_TOOLS}/.evergreen/download-mongodb.sh
|
||||
|
||||
get_distro
|
||||
if [ -z "$MONGODB_DOWNLOAD_URL" ]; then
|
||||
get_mongodb_download_url_for "$DISTRO" "$MONGODB_VERSION"
|
||||
fi
|
||||
# Even though we have the MONGODB_DOWNLOAD_URL, we still call this to get the proper EXTRACT variable
|
||||
get_mongodb_download_url_for "$DISTRO"
|
||||
download_and_extract "$MONGODB_DOWNLOAD_URL" "$EXTRACT"
|
||||
|
||||
# run tests
|
||||
echo "Running $AUTH tests over $SSL, connecting to $MONGODB_URI"
|
||||
|
||||
export PATH="/opt/mongodbtoolchain/v2/bin:$PATH"
|
||||
NODE_ARTIFACTS_PATH="${PROJECT_DIRECTORY}/node-artifacts"
|
||||
export NVM_DIR="${NODE_ARTIFACTS_PATH}/nvm"
|
||||
[ -s "$NVM_DIR/nvm.sh" ] && \. "$NVM_DIR/nvm.sh"
|
||||
MONGODB_VERSION=${MONGODB_VERSION} MONGODB_ENVIRONMENT=${TOPOLOGY} npm test -- --local
|
||||
+80
@@ -0,0 +1,80 @@
|
||||
## Code of Conduct
|
||||
|
||||
### Our Pledge
|
||||
|
||||
In the interest of fostering an open and welcoming environment, we as
|
||||
contributors and maintainers pledge to making participation in our project and
|
||||
our community a harassment-free experience for everyone, regardless of age,
|
||||
body size, disability, ethnicity, gender identity and expression, level of
|
||||
experience, nationality, personal appearance, race, religion, or sexual
|
||||
identity and orientation.
|
||||
|
||||
Please also take a moment to review [MongoDB's core values][mdb-core-values].
|
||||
|
||||
### Our Standards
|
||||
|
||||
Examples of behavior that contributes to creating a positive environment
|
||||
include:
|
||||
|
||||
* Using welcoming and inclusive language
|
||||
* Being respectful of differing viewpoints and experiences
|
||||
* Gracefully accepting constructive criticism
|
||||
* Focusing on what is best for the community
|
||||
* Showing empathy towards other community members
|
||||
|
||||
Examples of unacceptable behavior by participants include:
|
||||
|
||||
* The use of sexualized language or imagery and unwelcome sexual attention or
|
||||
advances
|
||||
* Trolling, insulting/derogatory comments, and personal or political attacks
|
||||
* Public or private harassment
|
||||
* Publishing others' private information, such as a physical or electronic
|
||||
address, without explicit permission
|
||||
* Other conduct which could reasonably be considered inappropriate in a
|
||||
professional setting
|
||||
|
||||
### Our Responsibilities
|
||||
|
||||
Project maintainers are responsible for clarifying the standards of acceptable
|
||||
behavior and are expected to take appropriate and fair corrective action in
|
||||
response to any instances of unacceptable behavior.
|
||||
|
||||
Project maintainers have the right and responsibility to remove, edit, or
|
||||
reject comments, commits, code, wiki edits, issues, and other contributions
|
||||
that are not aligned to this Code of Conduct, or to ban temporarily or
|
||||
permanently any contributor for other behaviors that they deem inappropriate,
|
||||
threatening, offensive, or harmful.
|
||||
|
||||
### Scope
|
||||
|
||||
This Code of Conduct applies both within project spaces and in public spaces
|
||||
when an individual is representing the project or its community. Examples of
|
||||
representing a project or community include using an official project e-mail
|
||||
address, posting via an official social media account, or acting as an
|
||||
appointed representative at an online or offline event. Representation of a
|
||||
project may be further defined and clarified by project maintainers.
|
||||
|
||||
### Enforcement
|
||||
|
||||
Instances of abusive, harassing, or otherwise unacceptable behavior may be
|
||||
reported by contacting the project team, or by
|
||||
[contacting GitHub][github-report-abuse]. All complaints will be reviewed
|
||||
and investigated and will result in a response that is deemed necessary and
|
||||
appropriate to the circumstances. The project team is obligated to maintain
|
||||
confidentiality with regard to the reporter of an incident.
|
||||
Further details of specific enforcement policies may be posted separately.
|
||||
|
||||
Project maintainers who do not follow or enforce the Code of Conduct in good
|
||||
faith may face temporary or permanent repercussions as determined by other
|
||||
members of the project's leadership.
|
||||
|
||||
### Attribution
|
||||
|
||||
This Code of Conduct is adapted from the [Contributor Covenant][homepage],
|
||||
version [1.4][version].
|
||||
|
||||
|
||||
[github-report-abuse]: https://github.com/contact/report-abuse
|
||||
[homepage]: https://www.contributor-covenant.org/
|
||||
[mdb-core-values]: https://www.mongodb.com/company/
|
||||
[version]: https://www.contributor-covenant.org/version/1/4/
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
# Contributing
|
||||
|
||||
When contributing to this repository, please first discuss the change you wish
|
||||
to make via issue, pull request, or any other method with the owners of this
|
||||
repository before making a change.
|
||||
|
||||
Please note we have a [code of conduct][code-of-conduct],
|
||||
please follow it in all your interactions with the project.
|
||||
|
||||
## Commit messages
|
||||
|
||||
Please follow the [Angular commit style][angular-commit-style].
|
||||
This helps the team automate [CHANGELOG.md][changelog] generation.
|
||||
|
||||
## Pull Request Process
|
||||
|
||||
1. Update the README.md or similar documentation with details of changes you
|
||||
wish to make, if applicable.
|
||||
2. Add any appropriate tests.
|
||||
3. Make your code or other changes.
|
||||
4. Review guidelines such as
|
||||
[How to write the perfect pull request][github-perfect-pr], thanks!
|
||||
|
||||
|
||||
[angular-commit-style]: https://github.com/angular/angular.js/blob/master/DEVELOPERS.md#commits
|
||||
[changelog]: CHANGELOG.md
|
||||
[code-of-conduct]: CODE_OF_CONDUCT.md
|
||||
[github-perfect-pr]: https://blog.github.com/2015-01-21-how-to-write-the-perfect-pull-request/
|
||||
[mdb-core-values]: https://www.mongodb.com/company/
|
||||
+994
@@ -0,0 +1,994 @@
|
||||
# Change Log
|
||||
|
||||
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
|
||||
|
||||
<a name="3.1.3"></a>
|
||||
## [3.1.3](https://github.com/mongodb-js/mongodb-core/compare/v3.1.2...v3.1.3) (2018-08-25)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **buffer:** use safe-buffer polyfill to maintain compatibility ([728d897](https://github.com/mongodb-js/mongodb-core/commit/728d897))
|
||||
* **EJSON:** export the result of optionally requiring EJSON ([645d73d](https://github.com/mongodb-js/mongodb-core/commit/645d73d))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **kerberos:** bump kerberos dependency to `^1.0.0` ([1155ebe](https://github.com/mongodb-js/mongodb-core/commit/1155ebe))
|
||||
* **standard-version:** automate part of the release process ([4c768c4](https://github.com/mongodb-js/mongodb-core/commit/4c768c4))
|
||||
|
||||
|
||||
|
||||
<a name="3.1.2"></a>
|
||||
## [3.1.2](https://github.com/mongodb-js/mongodb-core/compare/v3.1.1...v3.1.2) (2018-08-13)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **mongos:** fix connection leak when mongos reconnects ([2453746](https://github.com/mongodb-js/mongodb-core/commit/2453746))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **bson:** update to bson ^1.1.x ([952a2f0](https://github.com/mongodb-js/mongodb-core/commit/952a2f0))
|
||||
|
||||
|
||||
|
||||
<a name="3.1.1"></a>
|
||||
## [3.1.1](https://github.com/mongodb-js/mongodb-core/compare/v3.0.6...v3.1.1) (2018-08-13)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **auth:** prevent stalling on authentication when connected ([6b4ac89](https://github.com/mongodb-js/mongodb-core/commit/6b4ac89))
|
||||
* **buffer:** replace deprecated Buffer constructor ([7c71e19](https://github.com/mongodb-js/mongodb-core/commit/7c71e19))
|
||||
* **commands:** check doc.cursor errors ([4f2b263](https://github.com/mongodb-js/mongodb-core/commit/4f2b263))
|
||||
* **cursor:** check for session presence independently ([7c76c62](https://github.com/mongodb-js/mongodb-core/commit/7c76c62))
|
||||
* **cursor:** check for sessions independently in core cursor ([cb5df28](https://github.com/mongodb-js/mongodb-core/commit/cb5df28))
|
||||
* **cursor:** typo in _find() ([95f7fd2](https://github.com/mongodb-js/mongodb-core/commit/95f7fd2))
|
||||
* **error:** attach command response to MongoWriteConcernError ([#322](https://github.com/mongodb-js/mongodb-core/issues/322)) ([24c5d06](https://github.com/mongodb-js/mongodb-core/commit/24c5d06))
|
||||
* **getmore-killcursor:** slaveOk shall not be included on these ([40fb2f4](https://github.com/mongodb-js/mongodb-core/commit/40fb2f4))
|
||||
* **kerberos:** loosen restrictions on kerberos versions ([c4add26](https://github.com/mongodb-js/mongodb-core/commit/c4add26))
|
||||
* **mongos:** use `incrementTransactionNumber` directly on session ([e230d54](https://github.com/mongodb-js/mongodb-core/commit/e230d54))
|
||||
* **pool:** ensure that lsid is sent in get requests to mongos ([ae820f6](https://github.com/mongodb-js/mongodb-core/commit/ae820f6))
|
||||
* **read-preference:** correct server sort for `nearest` selection ([dd4eb9a](https://github.com/mongodb-js/mongodb-core/commit/dd4eb9a))
|
||||
* **sdam:** we can't use Array.includes yet ([9c3b5ab](https://github.com/mongodb-js/mongodb-core/commit/9c3b5ab))
|
||||
* **server:** correct typo using `this` instead of `server` ([c54f040](https://github.com/mongodb-js/mongodb-core/commit/c54f040))
|
||||
* **sessions:** add `toBSON` method to `ClientSession` ([d95a4d1](https://github.com/mongodb-js/mongodb-core/commit/d95a4d1))
|
||||
* **sessions:** never send `endSessions` from a `ClientSession` ([05ffe82](https://github.com/mongodb-js/mongodb-core/commit/05ffe82))
|
||||
* **topology-description:** we can't use Object.values yet ([91df350](https://github.com/mongodb-js/mongodb-core/commit/91df350))
|
||||
* **transactions:** do not send txnNumber for non-write commands ([#308](https://github.com/mongodb-js/mongodb-core/issues/308)) ([eb67b1a](https://github.com/mongodb-js/mongodb-core/commit/eb67b1a))
|
||||
* **uri_parser:** ensure default port is 27017 ([426a95e](https://github.com/mongodb-js/mongodb-core/commit/426a95e))
|
||||
* **uri-parser:** Incorrect parsing of arrays ([fcff104](https://github.com/mongodb-js/mongodb-core/commit/fcff104))
|
||||
* **uri-parser:** Parse comma separated option values ([2dd1de0](https://github.com/mongodb-js/mongodb-core/commit/2dd1de0))
|
||||
* **wireprotocol:** only send bypassDocumentValidation if true ([a81678b](https://github.com/mongodb-js/mongodb-core/commit/a81678b))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **auth:** adds saslprep and SCRAM-SHA-256 ([506c087](https://github.com/mongodb-js/mongodb-core/commit/506c087))
|
||||
* **cursor:** implement cursor for new sdam implementation ([f289226](https://github.com/mongodb-js/mongodb-core/commit/f289226))
|
||||
* **cursor:** store operation time from initial query ([55e761e](https://github.com/mongodb-js/mongodb-core/commit/55e761e))
|
||||
* **error:** add more specific error type for write concern errors ([347c5d7](https://github.com/mongodb-js/mongodb-core/commit/347c5d7))
|
||||
* **Error:** adding error metadata field ([33be560](https://github.com/mongodb-js/mongodb-core/commit/33be560))
|
||||
* **kerberos:** expose warning for kerberos mismatch versions ([efc0e43](https://github.com/mongodb-js/mongodb-core/commit/efc0e43))
|
||||
* **max-staleness:** properly support a max staleness reducer ([d9c5c16](https://github.com/mongodb-js/mongodb-core/commit/d9c5c16))
|
||||
* **MongoTimeoutError:** add common class for timeout events ([c5b4752](https://github.com/mongodb-js/mongodb-core/commit/c5b4752))
|
||||
* **monitoring:** add support for server monitoring to `Server` ([30a394d](https://github.com/mongodb-js/mongodb-core/commit/30a394d))
|
||||
* **op-compressed:** add support for OP_COMPRESSED to new sdam impl ([8deec9b](https://github.com/mongodb-js/mongodb-core/commit/8deec9b))
|
||||
* **retryableWrites:** adding more support for retries ([d4c1597](https://github.com/mongodb-js/mongodb-core/commit/d4c1597))
|
||||
* **sdam-monitoring:** add basic monitoring for new Topology type ([bb0c522](https://github.com/mongodb-js/mongodb-core/commit/bb0c522))
|
||||
* **server:** add `command` support to new server class ([d9a8c05](https://github.com/mongodb-js/mongodb-core/commit/d9a8c05))
|
||||
* **server-selection:** add basic support for server selection ([ccc5e1d](https://github.com/mongodb-js/mongodb-core/commit/ccc5e1d))
|
||||
* **topology:** introduce a single Topology type, and test runner ([f35d773](https://github.com/mongodb-js/mongodb-core/commit/f35d773))
|
||||
* **topology-description:** add helper method for server ownership ([2c64c75](https://github.com/mongodb-js/mongodb-core/commit/2c64c75))
|
||||
* **txns:** add initial transaction interface for sessions ([ed76be0](https://github.com/mongodb-js/mongodb-core/commit/ed76be0))
|
||||
|
||||
|
||||
|
||||
<a name="3.1.0"></a>
|
||||
# [3.1.0](https://github.com/mongodb-js/mongodb-core/compare/v3.0.6...v3.1.0) (2018-06-27)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **auth:** prevent stalling on authentication when connected ([6b4ac89](https://github.com/mongodb-js/mongodb-core/commit/6b4ac89))
|
||||
* **cursor:** check for session presence independently ([7c76c62](https://github.com/mongodb-js/mongodb-core/commit/7c76c62))
|
||||
* **cursor:** check for sessions independently in core cursor ([cb5df28](https://github.com/mongodb-js/mongodb-core/commit/cb5df28))
|
||||
* **error:** attach command response to MongoWriteConcernError ([#322](https://github.com/mongodb-js/mongodb-core/issues/322)) ([24c5d06](https://github.com/mongodb-js/mongodb-core/commit/24c5d06))
|
||||
* **getmore-killcursor:** slaveOk shall not be included on these ([40fb2f4](https://github.com/mongodb-js/mongodb-core/commit/40fb2f4))
|
||||
* **kerberos:** loosen restrictions on kerberos versions ([c4add26](https://github.com/mongodb-js/mongodb-core/commit/c4add26))
|
||||
* **mongos:** use `incrementTransactionNumber` directly on session ([e230d54](https://github.com/mongodb-js/mongodb-core/commit/e230d54))
|
||||
* **pool:** ensure that lsid is sent in get requests to mongos ([ae820f6](https://github.com/mongodb-js/mongodb-core/commit/ae820f6))
|
||||
* **sdam:** we can't use Array.includes yet ([9c3b5ab](https://github.com/mongodb-js/mongodb-core/commit/9c3b5ab))
|
||||
* **sessions:** add `toBSON` method to `ClientSession` ([d95a4d1](https://github.com/mongodb-js/mongodb-core/commit/d95a4d1))
|
||||
* **sessions:** never send `endSessions` from a `ClientSession` ([05ffe82](https://github.com/mongodb-js/mongodb-core/commit/05ffe82))
|
||||
* **topology-description:** we can't use Object.values yet ([91df350](https://github.com/mongodb-js/mongodb-core/commit/91df350))
|
||||
* **transactions:** do not send txnNumber for non-write commands ([#308](https://github.com/mongodb-js/mongodb-core/issues/308)) ([eb67b1a](https://github.com/mongodb-js/mongodb-core/commit/eb67b1a))
|
||||
* **wireprotocol:** only send bypassDocumentValidation if true ([a81678b](https://github.com/mongodb-js/mongodb-core/commit/a81678b))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **auth:** adds saslprep and SCRAM-SHA-256 ([506c087](https://github.com/mongodb-js/mongodb-core/commit/506c087))
|
||||
* **cursor:** implement cursor for new sdam implementation ([f289226](https://github.com/mongodb-js/mongodb-core/commit/f289226))
|
||||
* **cursor:** store operation time from initial query ([55e761e](https://github.com/mongodb-js/mongodb-core/commit/55e761e))
|
||||
* **error:** add more specific error type for write concern errors ([347c5d7](https://github.com/mongodb-js/mongodb-core/commit/347c5d7))
|
||||
* **Error:** adding error metadata field ([33be560](https://github.com/mongodb-js/mongodb-core/commit/33be560))
|
||||
* **kerberos:** expose warning for kerberos mismatch versions ([efc0e43](https://github.com/mongodb-js/mongodb-core/commit/efc0e43))
|
||||
* **max-staleness:** properly support a max staleness reducer ([d9c5c16](https://github.com/mongodb-js/mongodb-core/commit/d9c5c16))
|
||||
* **MongoTimeoutError:** add common class for timeout events ([c5b4752](https://github.com/mongodb-js/mongodb-core/commit/c5b4752))
|
||||
* **op-compressed:** add support for OP_COMPRESSED to new sdam impl ([8deec9b](https://github.com/mongodb-js/mongodb-core/commit/8deec9b))
|
||||
* **retryableWrites:** adding more support for retries ([d4c1597](https://github.com/mongodb-js/mongodb-core/commit/d4c1597))
|
||||
* **sdam-monitoring:** add basic monitoring for new Topology type ([bb0c522](https://github.com/mongodb-js/mongodb-core/commit/bb0c522))
|
||||
* **server:** add `command` support to new server class ([d9a8c05](https://github.com/mongodb-js/mongodb-core/commit/d9a8c05))
|
||||
* **server-selection:** add basic support for server selection ([ccc5e1d](https://github.com/mongodb-js/mongodb-core/commit/ccc5e1d))
|
||||
* **topology:** introduce a single Topology type, and test runner ([f35d773](https://github.com/mongodb-js/mongodb-core/commit/f35d773))
|
||||
* **topology-description:** add helper method for server ownership ([2c64c75](https://github.com/mongodb-js/mongodb-core/commit/2c64c75))
|
||||
* **txns:** add initial transaction interface for sessions ([ed76be0](https://github.com/mongodb-js/mongodb-core/commit/ed76be0))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.6"></a>
|
||||
## [3.0.6](https://github.com/mongodb-js/mongodb-core/compare/v3.0.5...v3.0.6) (2018-04-09)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **2.6-protocol:** kill cursor callback is called by pool now ([65f2bf7](https://github.com/mongodb-js/mongodb-core/commit/65f2bf7))
|
||||
* **evergreen:** change name to id ([9303e12](https://github.com/mongodb-js/mongodb-core/commit/9303e12))
|
||||
* **evergreen:** change nvm path to local ([e42ea5b](https://github.com/mongodb-js/mongodb-core/commit/e42ea5b))
|
||||
* **evergreen:** pass in flag through npm scripts ([85708dd](https://github.com/mongodb-js/mongodb-core/commit/85708dd))
|
||||
* **pool:** ensure noResponse callback is only called if cb exists ([5281605](https://github.com/mongodb-js/mongodb-core/commit/5281605))
|
||||
* **replset:** only remove primary if primary is there ([1acd288](https://github.com/mongodb-js/mongodb-core/commit/1acd288))
|
||||
* **test-environments:** ensure all servers run on separate ports ([b63e5d8](https://github.com/mongodb-js/mongodb-core/commit/b63e5d8))
|
||||
* **uri_parser:** support a default database on mongodb+srv uris ([be01ffe](https://github.com/mongodb-js/mongodb-core/commit/be01ffe))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **apm:** add events for command monitoring support in core ([37dce9c](https://github.com/mongodb-js/mongodb-core/commit/37dce9c))
|
||||
* **evergreen:** add evergreen config based on drivers skeleton ([b71da99](https://github.com/mongodb-js/mongodb-core/commit/b71da99))
|
||||
* **evergreen:** use evergreen flag when running tests ([55dff3b](https://github.com/mongodb-js/mongodb-core/commit/55dff3b))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.5"></a>
|
||||
## [3.0.5](https://github.com/mongodb-js/mongodb-core/compare/v3.0.4...v3.0.5) (2018-03-14)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **sessions:** adding implicit cursor session support ([1607321](https://github.com/mongodb-js/mongodb-core/commit/1607321))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.4"></a>
|
||||
## [3.0.4](https://github.com/mongodb-js/mongodb-core/compare/v3.0.3...v3.0.4) (2018-03-05)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **connection:** ensure socket options are applied to ssl sockets ([e5ff927](https://github.com/mongodb-js/mongodb-core/commit/e5ff927))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.3"></a>
|
||||
## [3.0.3](https://github.com/mongodb-js/mongodb-core/compare/v3.0.2...v3.0.3) (2018-02-23)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **connection:** make pool not try to reconnect forever when reconnectTries = 0 ([#275](https://github.com/mongodb-js/mongodb-core/issues/275)) ([2d3fa98](https://github.com/mongodb-js/mongodb-core/commit/2d3fa98)), closes [Automattic/mongoose#6028](https://github.com/Automattic/mongoose/issues/6028)
|
||||
* **retryableWrites:** only remove primary after retry ([#274](https://github.com/mongodb-js/mongodb-core/issues/274)) ([7ac171e](https://github.com/mongodb-js/mongodb-core/commit/7ac171e))
|
||||
* **sessions:** actually allow ending of sessions ([2b81bb6](https://github.com/mongodb-js/mongodb-core/commit/2b81bb6))
|
||||
* **uri-parser:** do not use `hasOwnProperty` to detect ssl ([69d16c7](https://github.com/mongodb-js/mongodb-core/commit/69d16c7))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **sessions:** adding endAllPooledSessions helper method ([d7804ed](https://github.com/mongodb-js/mongodb-core/commit/d7804ed))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.2"></a>
|
||||
## [3.0.2](https://github.com/mongodb-js/mongodb-core/compare/v3.0.1...v3.0.2) (2018-01-29)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **cursor:** check for autoReconnect option only for single server ([645d6df](https://github.com/mongodb-js/mongodb-core/commit/645d6df))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **mongodb+srv:** add support for mongodb+srv to the uri parser ([19b42ce](https://github.com/mongodb-js/mongodb-core/commit/19b42ce))
|
||||
* **uri-parser:** add initial implementation of uri parser for core ([8f797a7](https://github.com/mongodb-js/mongodb-core/commit/8f797a7))
|
||||
* **uri-parser:** expose the connection string parser as api ([fdeca2f](https://github.com/mongodb-js/mongodb-core/commit/fdeca2f))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.1"></a>
|
||||
## [3.0.1](https://github.com/mongodb-js/mongodb-core/compare/v3.0.0...v3.0.1) (2017-12-24)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **connection:** correct erroneous use of `this` in helper method ([06b9388](https://github.com/mongodb-js/mongodb-core/commit/06b9388))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.0"></a>
|
||||
# [3.0.0](https://github.com/christkv/mongodb-core/compare/v3.0.0-rc0...v3.0.0) (2017-12-23)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **connection:** ensure connection cleanup before fallback retry ([de62615](https://github.com/christkv/mongodb-core/commit/de62615))
|
||||
* **mock-server:** expose potential errors in message handlers ([65dcca4](https://github.com/christkv/mongodb-core/commit/65dcca4))
|
||||
* **mongos:** remove listener on destroy event ([243e942](https://github.com/christkv/mongodb-core/commit/243e942)), closes [#257](https://github.com/christkv/mongodb-core/issues/257)
|
||||
* **sdam:** more explicit wire protocol error message ([6d6d19a](https://github.com/christkv/mongodb-core/commit/6d6d19a))
|
||||
* **secondaries:** fixes connection with secondary readPreference ([#258](https://github.com/christkv/mongodb-core/issues/258)) ([0060ad7](https://github.com/christkv/mongodb-core/commit/0060ad7))
|
||||
* **sessions:** ensure that we ignore session details from arbiters ([de0105c](https://github.com/christkv/mongodb-core/commit/de0105c))
|
||||
* **sharded-tests:** add `shardsvr` cmdline opt, wait for async fns ([867b080](https://github.com/christkv/mongodb-core/commit/867b080))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **connection:** attempt both ipv6 and ipv4 when no family entered ([#260](https://github.com/christkv/mongodb-core/issues/260)) ([107bae5](https://github.com/christkv/mongodb-core/commit/107bae5))
|
||||
|
||||
|
||||
|
||||
<a name="3.0.0-rc0"></a>
|
||||
# 3.0.0-rc0 (2017-12-05)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **auth-plain:** only use BSON -after- requiring it ([4934adf](https://github.com/christkv/mongodb-core/commit/4934adf))
|
||||
* **auth-scram:** cache the ScramSHA1 salted passwords up to 200 entries ([31ef03a](https://github.com/christkv/mongodb-core/commit/31ef03a))
|
||||
* **client-session:** don't report errors for endSessions commands ([c34eaf5](https://github.com/christkv/mongodb-core/commit/c34eaf5))
|
||||
* **connection:** default `family` to undefined rather than 4 ([c1b5e04](https://github.com/christkv/mongodb-core/commit/c1b5e04))
|
||||
* **connection:** fixing leak in 3.0.0 ([#235](https://github.com/christkv/mongodb-core/issues/235)) ([fc669c0](https://github.com/christkv/mongodb-core/commit/fc669c0))
|
||||
* **cursor:** avoid waiting for reconnect if reconnect disabled ([43e9b23](https://github.com/christkv/mongodb-core/commit/43e9b23))
|
||||
* **cursor:** callback with server response on `_find` ([6999459](https://github.com/christkv/mongodb-core/commit/6999459))
|
||||
* **errors:** export MongoError and MongoNetworkError at top-level ([972064a](https://github.com/christkv/mongodb-core/commit/972064a))
|
||||
* **errors:** throw MongoNetworkError from more places ([2cec239](https://github.com/christkv/mongodb-core/commit/2cec239))
|
||||
* **errors:** use subclassing for MongoNetworkError ([a132830](https://github.com/christkv/mongodb-core/commit/a132830))
|
||||
* **errors:** use util.inherits() and protect edge case ([c953246](https://github.com/christkv/mongodb-core/commit/c953246))
|
||||
* **mocha_server_tests:** rename confusing variable to fix tests ([a9fbae2](https://github.com/christkv/mongodb-core/commit/a9fbae2))
|
||||
* **mock-tests:** ensure all servers are properly cleaned up ([5dafc86](https://github.com/christkv/mongodb-core/commit/5dafc86))
|
||||
* **package:** upgrade mongodb-test-runner with bug fix ([5b2e99e](https://github.com/christkv/mongodb-core/commit/5b2e99e))
|
||||
* **pool:** check topology exists before verifying session support ([0aa146d](https://github.com/christkv/mongodb-core/commit/0aa146d))
|
||||
* **pool:** ensure inUse and connecting queues are cleared on reauth ([aa2840d](https://github.com/christkv/mongodb-core/commit/aa2840d))
|
||||
* **pool:** ensure that errors are propagated on force destroy ([8f8ad56](https://github.com/christkv/mongodb-core/commit/8f8ad56))
|
||||
* **pool:** ensure workItem is not null before accessing properties ([2143963](https://github.com/christkv/mongodb-core/commit/2143963))
|
||||
* **pool_tests:** remove .only ([8172137](https://github.com/christkv/mongodb-core/commit/8172137))
|
||||
* **retryable-writes:** don't increment `txnNumber` on retries ([e7c2242](https://github.com/christkv/mongodb-core/commit/e7c2242))
|
||||
* **retryable-writes:** network errors are retryable, inverted logic ([2727551](https://github.com/christkv/mongodb-core/commit/2727551))
|
||||
* **scram:** cache salted data, not the original data ([0cbe95f](https://github.com/christkv/mongodb-core/commit/0cbe95f))
|
||||
* **SDAM:** emit SDAM events on close and reconnect ([3451ff0](https://github.com/christkv/mongodb-core/commit/3451ff0))
|
||||
* **server:** avoid waiting for reconnect if reconnect disabled ([611a352](https://github.com/christkv/mongodb-core/commit/611a352))
|
||||
* **server:** correct minor typo in porting 2.x patch ([d92efec](https://github.com/christkv/mongodb-core/commit/d92efec))
|
||||
* **server_tests:** change 'this' to 'self' in some server tests ([992d9e9](https://github.com/christkv/mongodb-core/commit/992d9e9))
|
||||
* **server_tests:** fix errors in broken test ([1602e4d](https://github.com/christkv/mongodb-core/commit/1602e4d))
|
||||
* **server-session-pool:** don't add expired sessions to the pool ([8f48b89](https://github.com/christkv/mongodb-core/commit/8f48b89))
|
||||
* **server-session-pool:** ensure the queue is LIFO ([ac68e76](https://github.com/christkv/mongodb-core/commit/ac68e76))
|
||||
* **utils:** don't throw if no snappy ([55bf2ad](https://github.com/christkv/mongodb-core/commit/55bf2ad))
|
||||
* **wire-protocol:** 2.6 killCursor should not way for reply ([7337d91](https://github.com/christkv/mongodb-core/commit/7337d91))
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **cluster-time:** ensure clusterTime makes it to outgoing commands ([e700b79](https://github.com/christkv/mongodb-core/commit/e700b79))
|
||||
* **cluster-time:** track incoming cluster time gossiping ([c910706](https://github.com/christkv/mongodb-core/commit/c910706))
|
||||
* **compression:** implement wire protocol compression support ([2356ffb](https://github.com/christkv/mongodb-core/commit/2356ffb))
|
||||
* **connection-spy:** add class for monitoring active connections ([6dd6db3](https://github.com/christkv/mongodb-core/commit/6dd6db3))
|
||||
* **errors:** create MongoNetworkError ([df12740](https://github.com/christkv/mongodb-core/commit/df12740))
|
||||
* **inital-cluster-time:** allow session to define initia value ([e3a1c8b](https://github.com/christkv/mongodb-core/commit/e3a1c8b))
|
||||
* **mock:** support a means of consistently cleaning up mock servers ([ab3b70b](https://github.com/christkv/mongodb-core/commit/ab3b70b))
|
||||
* **mock-server:** add the ability to set a message handler ([9a8b815](https://github.com/christkv/mongodb-core/commit/9a8b815))
|
||||
* **operation-time:** track operationTime in relevant sessions ([8d512f1](https://github.com/christkv/mongodb-core/commit/8d512f1))
|
||||
* **pool:** introduce the concept of a minimum pool size ([b01b1f8](https://github.com/christkv/mongodb-core/commit/b01b1f8))
|
||||
* **replset:** more verbose replica set errors emission ([6d5eccd](https://github.com/christkv/mongodb-core/commit/6d5eccd))
|
||||
* **retryable-writes:** add mongos support for retryable writes ([7778067](https://github.com/christkv/mongodb-core/commit/7778067))
|
||||
* **retryable-writes:** initial support on replicasets ([73ac688](https://github.com/christkv/mongodb-core/commit/73ac688))
|
||||
* **retryable-writes:** retry on "not master" stepdown errors ([028aec7](https://github.com/christkv/mongodb-core/commit/028aec7))
|
||||
* **server-check:** reintroduce server version check ([486aace](https://github.com/christkv/mongodb-core/commit/486aace))
|
||||
* **server-session-pool:** implement session pool per spect ([a1d5b22](https://github.com/christkv/mongodb-core/commit/a1d5b22))
|
||||
* **session:** allow `session` options to be passed to write cmds ([5da75e4](https://github.com/christkv/mongodb-core/commit/5da75e4))
|
||||
* **sessions:** add equality operator to ease readability ([6510d7d](https://github.com/christkv/mongodb-core/commit/6510d7d))
|
||||
* **sessions:** export all sessions types on the top level ([35265b3](https://github.com/christkv/mongodb-core/commit/35265b3))
|
||||
* **sessions:** support sessions with cursors with find/getMore ([a016602](https://github.com/christkv/mongodb-core/commit/a016602))
|
||||
* **sessions:** track `logicalSessionTimeoutMinutes` for sessions ([11865bf](https://github.com/christkv/mongodb-core/commit/11865bf))
|
||||
* **ssl:** adding ssl options ciphers and ecdhCurve ([c839d5c](https://github.com/christkv/mongodb-core/commit/c839d5c))
|
||||
* **test/:** convert server_tests, undefined_tests, replset_tests, replset_state_tests, and repleset_server_selection_tests to run with mongodb-test-runner ([3a7c5fd](https://github.com/christkv/mongodb-core/commit/3a7c5fd))
|
||||
|
||||
|
||||
2.1.16 2017-10-11
|
||||
-----------------
|
||||
* avoid waiting for reconnect if reconnect disabled in Server topology
|
||||
* avoid waiting for reconnect if reconnect disabled in Cursor
|
||||
* NODE-990 cache the ScramSHA1 salted passwords up to 200 entries
|
||||
* NODE-1153 ensure that errors are propagated on force destroy
|
||||
* NODE-1153 ensure inUse and connecting queues are cleared on reauth
|
||||
|
||||
2.1.15 2017-08-08
|
||||
-----------------
|
||||
* Emit SDAM events on close and reconnect
|
||||
|
||||
2.1.14 2017-07-07
|
||||
-----------------
|
||||
* NODE-1073 updates scram.js hi() algorithm to utilize crypto.pbkdf2Sync()
|
||||
* NODE-1049 only include primary server if there are no secondary servers for
|
||||
readPrefrence secondaryPreferred
|
||||
* moved `assign` polyfill to shared utils, replace usage of `extend` in tests
|
||||
|
||||
2.1.13 2017-06-19
|
||||
-----------------
|
||||
* NODE-1039 ensure we force destroy server instances, forcing queue to be flushed.
|
||||
* Use actual server type in standalone SDAM events.
|
||||
|
||||
2.1.12 2017-06-02
|
||||
-----------------
|
||||
* NODE-1019 Set keepAlive to 300 seconds or 1/2 of socketTimeout if socketTimeout < keepAlive.
|
||||
* Minor fix to report the correct state on error.
|
||||
* NODE-1020 'family' was added to options to provide high priority for ipv6 addresses (Issue #1518, https://github.com/firej).
|
||||
* Fix require_optional loading of bson-ext.
|
||||
* Ensure no errors are thrown by replset if topology is destroyed before it finished connecting.
|
||||
* NODE-999 SDAM fixes for Mongos and single Server event emitting.
|
||||
* NODE-1014 Set socketTimeout to default to 360 seconds.
|
||||
* NODE-1019 Set keepAlive to 300 seconds or 1/2 of socketTimeout if socketTimeout < keepAlive.
|
||||
|
||||
2.1.11 2017-05-22
|
||||
-----------------
|
||||
* NODE-987 Clear out old intervalIds on when calling topologyMonitor.
|
||||
* NODE-987 Moved filtering to pingServer method and added test case.
|
||||
* Check for connection destroyed just before writing out and flush out operations correctly if it is (Issue #179, https://github.com/jmholzinger).
|
||||
* NODE-989 Refactored Replicaset monitoring to correcly monitor newly added servers, Also extracted setTimeout and setInterval to use custom wrappers Timeout and Interva.
|
||||
|
||||
2.1.10 2017-04-18
|
||||
-----------------
|
||||
* NODE-981 delegate auth to replset/mongos if inTopology is set.
|
||||
* NODE-978 Wrap connection.end in try/catch for node 0.10.x issue causing exceptions to be thrown, Also surfaced getConnection for mongos and replset.
|
||||
* Remove dynamic require (Issue #175, https://github.com/tellnes).
|
||||
* NODE-696 Handle interrupted error for createIndexes.
|
||||
* Fixed isse when user is executing find command using Server.command and it get interpreted as a wire protcol message, #172.
|
||||
* NODE-966 promoteValues not being promoted correctly to getMore.
|
||||
* Merged in fix for flushing out monitoring operations.
|
||||
|
||||
2.1.9 2017-03-17
|
||||
----------------
|
||||
* Return lastIsMaster correctly when connecting with secondaryOnlyConnectionAllowed is set to true and only a secondary is available in replica state.
|
||||
* Clone options when passed to wireProtocol handler to avoid intermittent modifications causing errors.
|
||||
* Ensure SSL error propegates better for Replset connections when there is a SSL validation error.
|
||||
* NODE-957 Fixed issue where < batchSize not causing cursor to be closed on execution of first batch.
|
||||
* NODE-958 Store reconnectConnection on pool object to allow destroy to close immediately.
|
||||
|
||||
2.1.8 2017-02-13
|
||||
----------------
|
||||
* NODE-925 ensure we reschedule operations while pool is < poolSize while pool is growing and there are no connections with not currently performing work.
|
||||
* NODE-927 fixes issue where authentication was performed against arbiter instances.
|
||||
* NODE-915 Normalize all host names to avoid comparison issues.
|
||||
* Fixed issue where pool.destroy would never finish due to a single operation not being executed and keeping it open.
|
||||
|
||||
2.1.7 2017-01-24
|
||||
----------------
|
||||
* NODE-919 ReplicaSet connection does not close immediately (Issue #156).
|
||||
* NODE-901 Fixed bug when normalizing host names.
|
||||
* NODE-909 Fixed readPreference issue caused by direct connection to primary.
|
||||
* NODE-910 Fixed issue when bufferMaxEntries == 0 and read preference set to nearest.
|
||||
|
||||
2.1.6 2017-01-13
|
||||
----------------
|
||||
* NODE-908 Keep auth contexts in replset and mongos topology to ensure correct application of authentication credentials when primary is first server to be detected causing an immediate connect event to happen.
|
||||
|
||||
2.1.5 2017-01-11
|
||||
----------------
|
||||
* updated bson and bson-ext dependencies to 1.0.4 to work past early node 4.x.x version having a broken Buffer.from implementation.
|
||||
|
||||
2.1.4 2017-01-03
|
||||
----------------
|
||||
* updated bson and bson-ext dependencies to 1.0.3 due to util.inspect issue with ObjectId optimizations.
|
||||
|
||||
2.1.3 2017-01-03
|
||||
----------------
|
||||
* Monitoring operations are re-scheduled in pool if it cannot find a connection that does not already have scheduled work on it, this is to avoid the monitoring socket timeout being applied to any existing operations on the socket due to pipelining
|
||||
* Moved replicaset monitoring away from serial mode and to parallel mode.
|
||||
* updated bson and bson-ext dependencies to 1.0.2.
|
||||
|
||||
2.1.2 2016-12-10
|
||||
----------------
|
||||
* Delay topologyMonitoring on successful attemptReconnect as no need to run a full scan immediately.
|
||||
* Emit reconnect event in primary joining when in connected status for a replicaset.
|
||||
|
||||
2.1.1 2016-12-08
|
||||
----------------
|
||||
* Updated bson library to 1.0.1.
|
||||
* Added optional support for bson-ext 1.0.1.
|
||||
|
||||
2.1.0 2016-12-05
|
||||
----------------
|
||||
* Updated bson library to 1.0.0.
|
||||
* Added optional support for bson-ext 1.0.0.
|
||||
* Expose property parserType allowing for identification of currently configured parser.
|
||||
|
||||
2.0.14 2016-11-29
|
||||
-----------------
|
||||
* Updated bson library to 0.5.7.
|
||||
* Dont leak connection.workItems elments when killCursor is called (Issue #150, https://github.com/mdlavin).
|
||||
* Remove unnecessary errors formatting (Issue #149, https://github.com/akryvomaz).
|
||||
* Only check isConnected against availableConnections (Issue #142).
|
||||
* NODE-838 Provide better error message on failed to connect on first retry for Mongos topology.
|
||||
* Set default servername to host is not passed through for sni.
|
||||
* Made monitoring happen on exclusive connection and using connectionTimeout to handle the wait time before failure (Issue #148).
|
||||
* NODE-859 Make minimum value of maxStalenessSeconds 90 seconds.
|
||||
* NODE-852 Fix Kerberos module deprecations on linux and windows and release new kerberos version.
|
||||
* NODE-850 Update Max Staleness implementation.
|
||||
* NODE-849 username no longer required for MONGODB-X509 auth.
|
||||
* NODE-848 BSON Regex flags must be alphabetically ordered.
|
||||
* NODE-846 Create notice for all third party libraries.
|
||||
* NODE-843 Executing bulk operations overwrites write concern parameter.
|
||||
* NODE-842 Re-sync SDAM and SDAM Monitoring tests from Specs repo.
|
||||
* NODE-840 Resync CRUD spec tests.
|
||||
* Unescapable while(true) loop (Issue #152).
|
||||
|
||||
2.0.13 2016-10-21
|
||||
-----------------
|
||||
* Updated bson library to 0.5.6.
|
||||
- Included cyclic dependency detection
|
||||
* Fire callback when topology was destroyed (Issue #147, https://github.com/vkarpov15).
|
||||
* Refactoring to support pipelining ala 1.4.x branch will retaining the benefits of the growing/shrinking pool (Issue #146).
|
||||
* Fix typo in serverHeartbeatFailed event name (Issue #143, https://github.com/jakesjews).
|
||||
* NODE-798 Driver hangs on count command in replica set with one member (Issue #141, https://github.com/isayme).
|
||||
|
||||
2.0.12 2016-09-15
|
||||
-----------------
|
||||
* fix debug logging message not printing server name.
|
||||
* fixed application metadata being sent by wrong ismaster.
|
||||
* NODE-812 Fixed mongos stall due to proxy monitoring ismaster failure causing reconnect.
|
||||
* NODE-818 Replicaset timeouts in initial connect sequence can "no primary found".
|
||||
* Updated bson library to 0.5.5.
|
||||
* Added DBPointer up conversion to DBRef.
|
||||
|
||||
2.0.11 2016-08-29
|
||||
-----------------
|
||||
* NODE-803, Fixed issue in how the latency window is calculated for Mongos topology causing issues for single proxy connections.
|
||||
* Avoid timeout in attemptReconnect causing multiple attemptReconnect attempts to happen (Issue #134, https://github.com/dead-horse).
|
||||
* Ensure promoteBuffers is propagated in same fashion as promoteValues and promoteLongs
|
||||
|
||||
2.0.10 2016-08-23
|
||||
-----------------
|
||||
* Added promoteValues flag (default to true) to allow user to specify they only want wrapped BSON values back instead of promotion to native types.
|
||||
* Do not close mongos proxy connection on failed ismaster check in ha process (Issue #130).
|
||||
|
||||
2.0.9 2016-08-19
|
||||
----------------
|
||||
* Allow promoteLongs to be passed in through Response.parse method and overrides default set on the connection.
|
||||
* NODE-798 Driver hangs on count command in replica set with one member.
|
||||
* Allow promoteLongs to be passed in through Response.parse method and overrides default set on the connection.
|
||||
* Allow passing in servername for TLS connections for SNI support.
|
||||
|
||||
2.0.8 2016-08-16
|
||||
----------------
|
||||
* Allow execution of store operations indepent of having both a primary and secondary available (Issue #123).
|
||||
* Fixed command execution issue for mongos to ensure buffering of commands when no mongos available.
|
||||
* Added hashed connection names and fullResult.
|
||||
* Updated bson library to 0.5.3.
|
||||
* Wrap callback in nextTick to ensure exceptions are thrown correctly.
|
||||
|
||||
2.0.7 2016-07-28
|
||||
----------------
|
||||
* Allow primary to be returned when secondaryPreferred is passed (Issue #117, https://github.com/dhendo).
|
||||
* Added better warnings when passing in illegal seed list members to a Mongos topology.
|
||||
* Minor attemptReconnect bug that would cause multiple attemptReconnect to run in parallel.
|
||||
* Fix wrong opType passed to disconnectHandler.add (Issue #121, https://github.com/adrian-gierakowski)
|
||||
* Implemented domain backward comp support enabled via domainsEnabled options on Server/ReplSet/Mongos and MongoClient.connect.
|
||||
* Initial max staleness implementation for ReplSet and Mongos for 3.4 support.
|
||||
* Added handling of collation for 3.4 support.
|
||||
|
||||
2.0.6 2016-07-19
|
||||
----------------
|
||||
* Destroy connection on socket timeout due to newer node versions not closing the socket.
|
||||
|
||||
2.0.5 2016-07-15
|
||||
----------------
|
||||
* Minor fixes to handle faster MongoClient connectivity from the driver, allowing single server instances to detect if they are a proxy.
|
||||
* Added numberOfConsecutiveTimeouts to pool that will destroy the pool if the number of consecutive timeouts > reconnectTries.
|
||||
* Print warning if seedlist servers host name does not match the one provided in it's ismaster.me field for Replicaset members.
|
||||
* Fix issue where Replicaset connection would not succeeed if there the replicaset was a single primary server setup.
|
||||
|
||||
2.0.4 2016-07-11
|
||||
-----------------
|
||||
* Updated bson to version 0.5.1.
|
||||
* handle situation where user is providing seedlist names that do not match host list. fix allows for a single full discovery connection sweep before erroring out.
|
||||
* NODE-747 Polyfill for Object.assign for 0.12.x or 0.10.x.
|
||||
* NODE-746 Improves replicaset errors for wrong setName.
|
||||
|
||||
2.0.3 2016-07-08
|
||||
-----------------
|
||||
* Implemented Server Selection Specification test suite.
|
||||
* Added warning level to logger.
|
||||
* Added warning message when sockeTimeout < haInterval for Replset/Mongos.
|
||||
|
||||
2.0.2 2016-07-06
|
||||
-----------------
|
||||
* Mongos emits close event on no proxies available or when reconnect attempt fails.
|
||||
* Replset emits close event when no servers available or when attemptReconnect fails to reconnect.
|
||||
* Don't throw in auth methods but return error in callback.
|
||||
|
||||
2.0.1 2016-07-05
|
||||
-----------------
|
||||
* Added missing logout method on mongos proxy topology.
|
||||
* Fixed logger error serialization issue.
|
||||
* Documentation fixes.
|
||||
|
||||
2.0.0 2016-07-05
|
||||
-----------------
|
||||
* Moved all authentication and handling of growing/shrinking of pool connections into actual pool.
|
||||
* All authentication methods now handle both auth/reauthenticate and logout events.
|
||||
* Introduced logout method to get rid of onAll option for logout command.
|
||||
* Updated bson to 0.5.0 that includes Decimal128 support.
|
||||
|
||||
1.3.21 2016-05-30
|
||||
-----------------
|
||||
* Pool gets stuck if a connection marked for immediateRelease times out (Issue #99, https://github.com/nbrachet).
|
||||
* Make authentication process retry up to authenticationRetries at authenticationRetryIntervalMS interval.
|
||||
* Made ismaster replicaset calls operate with connectTimeout or monitorSocketTimeout to lower impact of big socketTimeouts on monitoring performance.
|
||||
* Make sure connections mark as "immediateRelease" don't linger the inUserConnections list. Otherwise, after that connection times out, getAll() incorrectly returns more connections than are effectively present, causing the pool to not get restarted by reconnectServer. (Issue #99, https://github.com/nbrachet).
|
||||
* Make cursor getMore or killCursor correctly trigger pool reconnect to single server if pool has not been destroyed.
|
||||
* Make ismaster monitoring for single server connection default to avoid user confusion due to change in behavior.
|
||||
|
||||
1.3.20 2016-05-25
|
||||
-----------------
|
||||
* NODE-710 Allow setting driver loggerLevel and logger function from MongoClient options.
|
||||
* Minor fix for SSL errors on connection attempts, minor fix to reconnect handler for the server.
|
||||
* Don't write to socket before having registered the callback for commands, work around for windows issuing error events twice on node.js when socket gets destroyed by firewall.
|
||||
* Fix minor issue where connectingServers would not be removed correctly causing single server connections to not auto-reconnect.
|
||||
|
||||
1.3.19 2016-05-17
|
||||
-----------------
|
||||
- Handle situation where a server connection in a replicaset sometimes fails to be destroyed properly due to being in the middle of authentication when the destroy method is called on the replicaset causing it to be orphaned and never collected.
|
||||
- Set keepAlive to false by default to work around bug in node.js for Windows XP and Windows 2003.
|
||||
- Ensure replicaset topology destroy is never called by SDAM.
|
||||
- Ensure all paths are correctly returned on inspectServer in replset.
|
||||
|
||||
1.3.18 2016-04-27
|
||||
-----------------
|
||||
- Hardened cursor connection handling for getMore and killCursor to ensure mid operation connection kill does not throw null exception.
|
||||
- Fixes for Node 6.0 support.
|
||||
|
||||
1.3.17 2016-04-26
|
||||
-----------------
|
||||
- Added improved handling of reconnect when topology is a single server.
|
||||
- Added better handling of $query queries passed down for 3.2 or higher.
|
||||
- Introduced getServerFrom method to topologies to let cursor grab a new pool for getMore and killCursors commands and not use connection pipelining.
|
||||
- NODE-693 Move authentication to be after ismaster call to avoid authenticating against arbiters.
|
||||
|
||||
1.3.16 2016-04-07
|
||||
-----------------
|
||||
- Only call unref on destroy if it exists to ensure proper working destroy method on early node v0.10.x versions.
|
||||
|
||||
1.3.15 2016-04-06
|
||||
-----------------
|
||||
- NODE-687 Fixed issue where a server object failed to be destroyed if the replicaset state did not update successfully. This could leave active connections accumulating over time.
|
||||
- Fixed some situations where all connections are flushed due to a single connection in the connection pool closing.
|
||||
|
||||
1.3.14 2016-04-01
|
||||
-----------------
|
||||
- Ensure server inquireServerState exits immediately on server.destroy call.
|
||||
- Refactored readPreference handling in 2.4, 2.6 and 3.2 wire protocol handling.
|
||||
|
||||
1.3.13 2016-03-30
|
||||
-----------------
|
||||
- Handle missing cursor on getMore when going through a mongos proxy by pinning to socket connection and not server.
|
||||
|
||||
1.3.12 2016-03-29
|
||||
-----------------
|
||||
- Mongos pickProxies fall back to closest mongos if no proxies meet latency window specified.
|
||||
|
||||
1.3.11 2016-03-29
|
||||
-----------------
|
||||
- isConnected method for mongos uses same selection code as getServer.
|
||||
- Exceptions in cursor getServer trapped and correctly delegated to high level handler.
|
||||
|
||||
1.3.10 2016-03-22
|
||||
-----------------
|
||||
- SDAM Monitoring emits diff for Replicasets to simplify detecting the state changes.
|
||||
- SDAM Monitoring correctly emits Mongos as serverDescriptionEvent.
|
||||
|
||||
1.3.9 2016-03-20
|
||||
----------------
|
||||
- Removed monitoring exclusive connection, should resolve timeouts and reconnects on idle replicasets where haInteval > socketTimeout.
|
||||
|
||||
1.3.8 2016-03-18
|
||||
----------------
|
||||
- Implements the SDAM monitoring specification.
|
||||
- Fix issue where cursor would error out and not be buffered when primary is not connected.
|
||||
|
||||
1.3.7 2016-03-16
|
||||
----------------
|
||||
- Fixed issue with replicasetInquirer where it could stop performing monitoring if there was no servers available.
|
||||
|
||||
1.3.6 2016-03-15
|
||||
----------------
|
||||
- Fixed raise condition where multiple replicasetInquirer operations could be started in parallel creating redundant connections.
|
||||
|
||||
1.3.5 2016-03-14
|
||||
----------------
|
||||
- Handle rogue SSL exceptions (Issue #85, https://github.com/durran).
|
||||
|
||||
1.3.4 2016-03-14
|
||||
----------------
|
||||
- Added unref options on server, replicaset and mongos (Issue #81, https://github.com/allevo)
|
||||
- cursorNotFound flag always false (Issue #83, https://github.com/xgfd)
|
||||
- refactor of events emission of fullsetup and all events (Issue #84, https://github.com/xizhibei)
|
||||
|
||||
1.3.3 2016-03-08
|
||||
----------------
|
||||
- Added support for promoteLongs option for command function.
|
||||
- Return connection if no callback available
|
||||
- Emit connect event when server reconnects after initial connection failed (Issue #76, https://github.com/vkarpov15)
|
||||
- Introduced optional monitoringSocketTimeout option to allow better control of SDAM monitoring timeouts.
|
||||
- Made monitoringSocketTimeout default to 30000 if no connectionTimeout value specified or if set to 0.
|
||||
- Fixed issue where tailable cursor would not retry even though cursor was still alive.
|
||||
- Disabled exhaust flag support to avoid issues where users could easily write code that would cause memory to run out.
|
||||
- Handle the case where the first command result document returns an empty list of documents but a live cursor.
|
||||
- Allow passing down off CANONICALIZE_HOST_NAME and SERVICE_REALM options for kerberos.
|
||||
|
||||
1.3.2 2016-02-09
|
||||
----------------
|
||||
- Harden MessageHandler in server.js to avoid issues where we cannot find a callback for an operation.
|
||||
- Ensure RequestId can never be larger than Max Number integer size.
|
||||
|
||||
1.3.1 2016-02-05
|
||||
----------------
|
||||
- Removed annoying missing Kerberos error (NODE-654).
|
||||
|
||||
1.3.0 2016-02-03
|
||||
----------------
|
||||
- Added raw support for the command function on topologies.
|
||||
- Fixed issue where raw results that fell on batchSize boundaries failed (Issue #72)
|
||||
- Copy over all the properties to the callback returned from bindToDomain, (Issue #72)
|
||||
- Added connection hash id to be able to reference connection host/name without leaking it outside of driver.
|
||||
- NODE-638, Cannot authenticate database user with utf-8 password.
|
||||
- Refactored pool to be worker queue based, minimizing the impact a slow query have on throughput as long as # slow queries < # connections in the pool.
|
||||
- Pool now grows and shrinks correctly depending on demand not causing a full pool reconnect.
|
||||
- Improvements in monitoring of a Replicaset where in certain situations the inquiry process could get exited.
|
||||
- Switched to using Array.push instead of concat for use cases of a lot of documents.
|
||||
- Fixed issue where re-authentication could loose the credentials if whole Replicaset disconnected at once.
|
||||
- Added peer optional dependencies support using require_optional module.
|
||||
|
||||
1.2.32 2016-01-12
|
||||
-----------------
|
||||
- Bumped bson to V0.4.21 to allow using minor optimizations.
|
||||
|
||||
1.2.31 2016-01-04
|
||||
-----------------
|
||||
- Allow connection to secondary if primaryPreferred or secondaryPreferred (Issue #70, https://github.com/leichter)
|
||||
|
||||
1.2.30 2015-12-23
|
||||
-----------------
|
||||
- Pool allocates size + 1 connections when using replicasets, reserving additional pool connection for monitoring exclusively.
|
||||
- Fixes bug when all replicaset members are down, that would cause it to fail to reconnect using the originally provided seedlist.
|
||||
|
||||
1.2.29 2015-12-17
|
||||
-----------------
|
||||
- Correctly emit close event when calling destroy on server topology.
|
||||
|
||||
1.2.28 2015-12-13
|
||||
-----------------
|
||||
- Backed out Prevent Maximum call stack exceeded by calling all callbacks on nextTick, (Issue #64, https://github.com/iamruinous) as it breaks node 0.10.x support.
|
||||
|
||||
1.2.27 2015-12-13
|
||||
-----------------
|
||||
- Added [options.checkServerIdentity=true] {boolean|function}. Ensure we check server identify during SSL, set to false to disable checking. Only works for Node 0.12.x or higher. You can pass in a boolean or your own checkServerIdentity override function, (Issue #29).
|
||||
- Prevent Maximum call stack exceeded by calling all callbacks on nextTick, (Issue #64, https://github.com/iamruinous).
|
||||
- State is not defined in mongos, (Issue #63, https://github.com/flyingfisher).
|
||||
- Fixed corner case issue on exhaust cursors on pre 3.0.x MongoDB.
|
||||
|
||||
1.2.26 2015-11-23
|
||||
-----------------
|
||||
- Converted test suite to use mongodb-topology-manager.
|
||||
- Upgraded bson library to V0.4.20.
|
||||
- Minor fixes for 3.2 readPreferences.
|
||||
|
||||
1.2.25 2015-11-23
|
||||
-----------------
|
||||
- Correctly error out when passed a seedlist of non-valid server members.
|
||||
|
||||
1.2.24 2015-11-20
|
||||
-----------------
|
||||
- Fix Automattic/mongoose#3481; flush callbacks on error, (Issue #57, https://github.com/vkarpov15).
|
||||
- $explain query for wire protocol 2.6 and 2.4 does not set number of returned documents to -1 but to 0.
|
||||
|
||||
1.2.23 2015-11-16
|
||||
-----------------
|
||||
- ismaster runs against admin.$cmd instead of system.$cmd.
|
||||
|
||||
1.2.22 2015-11-16
|
||||
-----------------
|
||||
- Fixes to handle getMore command errors for MongoDB 3.2
|
||||
- Allows the process to properly close upon a Db.close() call on the replica set by shutting down the haTimer and closing arbiter connections.
|
||||
|
||||
1.2.21 2015-11-07
|
||||
-----------------
|
||||
- Hardened the checking for replicaset equality checks.
|
||||
- OpReplay flag correctly set on Wire protocol query.
|
||||
- Mongos load balancing added, introduced localThresholdMS to control the feature.
|
||||
- Kerberos now a peerDependency, making it not install it by default in Node 5.0 or higher.
|
||||
|
||||
1.2.20 2015-10-28
|
||||
-----------------
|
||||
- Fixed bug in arbiter connection capping code.
|
||||
- NODE-599 correctly handle arrays of server tags in order of priority.
|
||||
- Fix for 2.6 wire protocol handler related to readPreference handling.
|
||||
- Added maxAwaitTimeMS support for 3.2 getMore to allow for custom timeouts on tailable cursors.
|
||||
- Make CoreCursor check for $err before saying that 'next' succeeded (Issue #53, https://github.com/vkarpov15).
|
||||
|
||||
1.2.19 2015-10-15
|
||||
-----------------
|
||||
- Make batchSize always be > 0 for 3.2 wire protocol to make it work consistently with pre 3.2 servers.
|
||||
- Locked to bson 0.4.19.
|
||||
|
||||
1.2.18 2015-10-15
|
||||
-----------------
|
||||
- Minor 3.2 fix for handling readPreferences on sharded commands.
|
||||
- Minor fixes to correctly pass APM specification test suite.
|
||||
|
||||
1.2.17 2015-10-08
|
||||
-----------------
|
||||
- Connections to arbiters only maintain a single connection.
|
||||
|
||||
1.2.15 2015-10-06
|
||||
-----------------
|
||||
- Set slaveOk to true for getMore and killCursors commands.
|
||||
- Don't swallow callback errors for 2.4 single server (Issue #49, https://github.com/vkarpov15).
|
||||
- Apply toString('hex') to each buffer in an array when logging (Issue #48, https://github.com/nbrachet).
|
||||
|
||||
1.2.14 2015-09-28
|
||||
-----------------
|
||||
- NODE-547 only emit error if there are any listeners.
|
||||
- Fixed APM issue with issuing readConcern.
|
||||
|
||||
1.2.13 2015-09-18
|
||||
-----------------
|
||||
- Added BSON serializer ignoreUndefined option for insert/update/remove/command/cursor.
|
||||
|
||||
1.2.12 2015-09-08
|
||||
-----------------
|
||||
- NODE-541 Added initial support for readConcern.
|
||||
|
||||
1.2.11 2015-08-31
|
||||
-----------------
|
||||
- NODE-535 If connectWithNoPrimary is true then primary-only connection is not allowed.
|
||||
- NODE-534 Passive secondaries are not allowed for secondaryOnlyConnectionAllowed.
|
||||
- Fixed filtering bug for logging (Issue 30, https://github.com/christkv/mongodb-core/issues/30).
|
||||
|
||||
1.2.10 2015-08-14
|
||||
-----------------
|
||||
- Added missing Mongos.prototype.parserType function.
|
||||
|
||||
1.2.9 2015-08-05
|
||||
----------------
|
||||
- NODE-525 Reset connectionTimeout after it's overwritten by tls.connect.
|
||||
- NODE-518 connectTimeoutMS is doubled in 2.0.39.
|
||||
|
||||
1.2.8 2015-07-24
|
||||
-----------------
|
||||
- Minor fix to handle 2.4.x errors better by correctly return driver layer issues.
|
||||
|
||||
1.2.7 2015-07-16
|
||||
-----------------
|
||||
- Refactoring to allow to tap into find/getmore/killcursor in cursors for APM monitoring in driver.
|
||||
|
||||
1.2.6 2015-07-14
|
||||
-----------------
|
||||
- NODE-505 Query fails to find records that have a 'result' property with an array value.
|
||||
|
||||
1.2.5 2015-07-14
|
||||
-----------------
|
||||
- NODE-492 correctly handle hanging replicaset monitoring connections when server is unavailable due to network partitions or firewalls dropping packets, configureable using the connectionTimeoutMS setting.
|
||||
|
||||
1.2.4 2015-07-07
|
||||
-----------------
|
||||
- NODE-493 staggering the socket connections to avoid overwhelming the mongod process.
|
||||
|
||||
1.2.3 2015-06-26
|
||||
-----------------
|
||||
- Minor bug fixes.
|
||||
|
||||
1.2.2 2015-06-22
|
||||
-----------------
|
||||
- Fix issue with SCRAM authentication causing authentication to return true on failed authentication (Issue 26, https://github.com/cglass17).
|
||||
|
||||
1.2.1 2015-06-17
|
||||
-----------------
|
||||
- Ensure serializeFunctions passed down correctly to wire protocol.
|
||||
|
||||
1.2.0 2015-06-17
|
||||
-----------------
|
||||
- Switching to using the 0.4.x pure JS serializer, removing dependency on C++ parser.
|
||||
- Refactoring wire protocol messages to avoid expensive size calculations of documents in favor of writing out an array of buffers to the sockets.
|
||||
- NODE-486 fixed issue related to limit and skip when calling toArray in 2.0 driver.
|
||||
- NODE-483 throw error if capabilities of topology is queries before topology has performed connection setup.
|
||||
- NODE-487 fixed issue where killcursor command was not being sent correctly on limit and skip queries.
|
||||
|
||||
1.1.33 2015-05-31
|
||||
-----------------
|
||||
- NODE-478 Work around authentication race condition in mongos authentication due to multi step authentication methods like SCRAM.
|
||||
|
||||
1.1.32 2015-05-20
|
||||
-----------------
|
||||
- After reconnect, it updates the allowable reconnect retries to the option settings (Issue #23, https://github.com/owenallenaz)
|
||||
|
||||
1.1.31 2015-05-19
|
||||
-----------------
|
||||
- Minor fixes for issues with re-authentication of mongos.
|
||||
|
||||
1.1.30 2015-05-18
|
||||
-----------------
|
||||
- Correctly emit 'all' event when primary + all secondaries have connected.
|
||||
|
||||
1.1.29 2015-05-17
|
||||
-----------------
|
||||
- NODE-464 Only use a single socket against arbiters and hidden servers.
|
||||
- Ensure we filter out hidden servers from any server queries.
|
||||
|
||||
1.1.28 2015-05-12
|
||||
-----------------
|
||||
- Fixed buffer compare for electionId for < node 12.0.2
|
||||
|
||||
1.1.27 2015-05-12
|
||||
-----------------
|
||||
- NODE-455 Update SDAM specification support to cover electionId and Mongos load balancing.
|
||||
|
||||
1.1.26 2015-05-06
|
||||
-----------------
|
||||
- NODE-456 Allow mongodb-core to pipeline commands (ex findAndModify+GLE) along the same connection and handle the returned results.
|
||||
- Fixes to make mongodb-core work for node 0.8.x when using scram and setImmediate.
|
||||
|
||||
1.1.25 2015-04-24
|
||||
-----------------
|
||||
- Handle lack of callback in crud operations when returning error on application closed.
|
||||
|
||||
1.1.24 2015-04-22
|
||||
-----------------
|
||||
- Error out when topology has been destroyed either by connection retries being exhausted or destroy called on topology.
|
||||
|
||||
1.1.23 2015-04-15
|
||||
-----------------
|
||||
- Standardizing mongoErrors and its API (Issue #14)
|
||||
- Creating a new connection is slow because of 100ms setTimeout() (Issue #17, https://github.com/vkarpov15)
|
||||
- remove mkdirp and rimraf dependencies (Issue #12)
|
||||
- Updated default value of param options.rejectUnauthorized to match documentation (Issue #16)
|
||||
- ISSUE: NODE-417 Resolution. Improving behavior of thrown errors (Issue #14, https://github.com/owenallenaz)
|
||||
- Fix cursor hanging when next() called on exhausted cursor (Issue #18, https://github.com/vkarpov15)
|
||||
|
||||
1.1.22 2015-04-10
|
||||
-----------------
|
||||
- Minor refactorings in cursor code to make extending the cursor simpler.
|
||||
- NODE-417 Resolution. Improving behavior of thrown errors using Error.captureStackTrace.
|
||||
|
||||
1.1.21 2015-03-26
|
||||
-----------------
|
||||
- Updated bson module to 0.3.0 that extracted the c++ parser into bson-ext and made it an optional dependency.
|
||||
|
||||
1.1.20 2015-03-24
|
||||
-----------------
|
||||
- NODE-395 Socket Not Closing, db.close called before full set finished initalizing leading to server connections in progress not being closed properly.
|
||||
|
||||
1.1.19 2015-03-21
|
||||
-----------------
|
||||
- Made kerberos module ~0.0 to allow for quicker releases due to io.js of kerberos module.
|
||||
|
||||
1.1.18 2015-03-17
|
||||
-----------------
|
||||
- Added support for minHeartbeatFrequencyMS on server reconnect according to the SDAM specification.
|
||||
|
||||
1.1.17 2015-03-16
|
||||
-----------------
|
||||
- NODE-377, fixed issue where tags would correctly be checked on secondary and nearest to filter out eligible server candidates.
|
||||
|
||||
1.1.16 2015-03-06
|
||||
-----------------
|
||||
- rejectUnauthorized parameter is set to true for ssl certificates by default instead of false.
|
||||
|
||||
1.1.15 2015-03-04
|
||||
-----------------
|
||||
- Removed check for type in replset pickserver function.
|
||||
|
||||
1.1.14 2015-02-26
|
||||
-----------------
|
||||
- NODE-374 correctly adding passive secondaries to the list of eligable servers for reads
|
||||
|
||||
1.1.13 2015-02-24
|
||||
-----------------
|
||||
- NODE-365 mongoDB native node.js driver infinite reconnect attempts (fixed issue around handling of retry attempts)
|
||||
|
||||
1.1.12 2015-02-16
|
||||
-----------------
|
||||
- Fixed cursor transforms for buffered document reads from cursor.
|
||||
|
||||
1.1.11 2015-02-02
|
||||
-----------------
|
||||
- Remove the required setName for replicaset connections, if not set it will pick the first setName returned.
|
||||
|
||||
1.1.10 2015-31-01
|
||||
-----------------
|
||||
- Added tranforms.doc option to cursor to allow for pr. document transformations.
|
||||
|
||||
1.1.9 2015-21-01
|
||||
----------------
|
||||
- Updated BSON dependency to 0.2.18 to fix issues with io.js and node.
|
||||
- Updated Kerberos dependency to 0.0.8 to fix issues with io.js and node.
|
||||
- Don't treat findOne() as a command cursor.
|
||||
- Refactored out state changes into methods to simplify read the next method.
|
||||
|
||||
1.1.8 2015-09-12
|
||||
----------------
|
||||
- Stripped out Object.defineProperty for performance reasons
|
||||
- Applied more performance optimizations.
|
||||
- properties cursorBatchSize, cursorSkip, cursorLimit are not methods setCursorBatchSize/cursorBatchSize, setCursorSkip/cursorSkip, setCursorLimit/cursorLimit
|
||||
|
||||
1.1.7 2014-18-12
|
||||
----------------
|
||||
- Use ns variable for getMore commands for command cursors to work properly with cursor version of listCollections and listIndexes.
|
||||
|
||||
1.1.6 2014-18-12
|
||||
----------------
|
||||
- Server manager fixed to support 2.2.X servers for travis test matrix.
|
||||
|
||||
1.1.5 2014-17-12
|
||||
----------------
|
||||
- Fall back to errmsg when creating MongoError for command errors
|
||||
|
||||
1.1.4 2014-17-12
|
||||
----------------
|
||||
- Added transform method support for cursor (initially just for initial query results) to support listCollections/listIndexes in 2.8.
|
||||
- Fixed variable leak in scram.
|
||||
- Fixed server manager to deal better with killing processes.
|
||||
- Bumped bson to 0.2.16.
|
||||
|
||||
1.1.3 2014-01-12
|
||||
----------------
|
||||
- Fixed error handling issue with nonce generation in mongocr.
|
||||
- Fixed issues with restarting servers when using ssl.
|
||||
- Using strict for all classes.
|
||||
- Cleaned up any escaping global variables.
|
||||
|
||||
1.1.2 2014-20-11
|
||||
----------------
|
||||
- Correctly encoding UTF8 collection names on wire protocol messages.
|
||||
- Added emitClose parameter to topology destroy methods to allow users to specify that they wish the topology to emit the close event to any listeners.
|
||||
|
||||
1.1.1 2014-14-11
|
||||
----------------
|
||||
- Refactored code to use prototype instead of privileged methods.
|
||||
- Fixed issue with auth where a runtime condition could leave replicaset members without proper authentication.
|
||||
- Several deopt optimizations for v8 to improve performance and reduce GC pauses.
|
||||
|
||||
1.0.5 2014-29-10
|
||||
----------------
|
||||
- Fixed issue with wrong namespace being created for command cursors.
|
||||
|
||||
1.0.4 2014-24-10
|
||||
----------------
|
||||
- switched from using shift for the cursor due to bad slowdown on big batchSizes as shift causes entire array to be copied on each call.
|
||||
|
||||
1.0.3 2014-21-10
|
||||
----------------
|
||||
- fixed error issuing problem on cursor.next when iterating over a huge dataset with a very small batchSize.
|
||||
|
||||
1.0.2 2014-07-10
|
||||
----------------
|
||||
- fullsetup is now defined as a primary and secondary being available allowing for all read preferences to be satisfied.
|
||||
- fixed issue with replset_state logging.
|
||||
|
||||
1.0.1 2014-07-10
|
||||
----------------
|
||||
- Dependency issue solved
|
||||
|
||||
1.0.0 2014-07-10
|
||||
----------------
|
||||
- Initial release of mongodb-core
|
||||
+201
@@ -0,0 +1,201 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "{}"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright {yyyy} {name of copyright owner}
|
||||
|
||||
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.
|
||||
+11
@@ -0,0 +1,11 @@
|
||||
NODE = node
|
||||
NPM = npm
|
||||
JSDOC = jsdoc
|
||||
name = all
|
||||
|
||||
generate_docs:
|
||||
# cp -R ./HISTORY.md ./docs/content/meta/release-notes.md
|
||||
hugo -s docs/reference -d ../../public
|
||||
$(JSDOC) -c conf.json -t docs/jsdoc-template/ -d ./public/api
|
||||
cp -R ./public/api/scripts ./public/.
|
||||
cp -R ./public/api/styles ./public/.
|
||||
+228
@@ -0,0 +1,228 @@
|
||||
[](http://travis-ci.org/mongodb-js/mongodb-core)
|
||||
[](https://coveralls.io/github/mongodb-js/mongodb-core?branch=1.3)
|
||||
|
||||
# Description
|
||||
|
||||
The MongoDB Core driver is the low level part of the 2.0 or higher MongoDB driver and is meant for library developers not end users. It does not contain any abstractions or helpers outside of the basic management of MongoDB topology connections, CRUD operations and authentication.
|
||||
|
||||
## MongoDB Node.JS Core Driver
|
||||
|
||||
| what | where |
|
||||
|---------------|------------------------------------------------|
|
||||
| documentation | http://mongodb.github.io/node-mongodb-native/ |
|
||||
| apidoc | http://mongodb.github.io/node-mongodb-native/ |
|
||||
| source | https://github.com/mongodb-js/mongodb-core |
|
||||
| mongodb | http://www.mongodb.org/ |
|
||||
|
||||
### Blogs of Engineers involved in the driver
|
||||
- Christian Kvalheim [@christkv](https://twitter.com/christkv) <http://christiankvalheim.com>
|
||||
|
||||
### Bugs / Feature Requests
|
||||
|
||||
Think you’ve found a bug? Want to see a new feature in node-mongodb-native? Please open a
|
||||
case in our issue management tool, JIRA:
|
||||
|
||||
- Create an account and login <https://jira.mongodb.org>.
|
||||
- Navigate to the NODE project <https://jira.mongodb.org/browse/NODE>.
|
||||
- Click **Create Issue** - Please provide as much information as possible about the issue type and how to reproduce it.
|
||||
|
||||
Bug reports in JIRA for all driver projects (i.e. NODE, PYTHON, CSHARP, JAVA) and the
|
||||
Core Server (i.e. SERVER) project are **public**.
|
||||
|
||||
### Questions and Bug Reports
|
||||
|
||||
* mailing list: https://groups.google.com/forum/#!forum/node-mongodb-native
|
||||
* jira: http://jira.mongodb.org/
|
||||
|
||||
### Change Log
|
||||
|
||||
http://jira.mongodb.org/browse/NODE
|
||||
|
||||
# QuickStart
|
||||
|
||||
The quick start guide will show you how to set up a simple application using Core driver and MongoDB. It scope is only how to set up the driver and perform the simple crud operations. For more inn depth coverage we encourage reading the tutorials.
|
||||
|
||||
## Create the package.json file
|
||||
|
||||
Let's create a directory where our application will live. In our case we will put this under our projects directory.
|
||||
|
||||
```
|
||||
mkdir myproject
|
||||
cd myproject
|
||||
```
|
||||
|
||||
Create a **package.json** using your favorite text editor and fill it in.
|
||||
|
||||
```json
|
||||
{
|
||||
"name": "myproject",
|
||||
"version": "1.0.0",
|
||||
"description": "My first project",
|
||||
"main": "index.js",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/christkv/myfirstproject.git"
|
||||
},
|
||||
"dependencies": {
|
||||
"mongodb-core": "~1.0"
|
||||
},
|
||||
"author": "Christian Kvalheim",
|
||||
"license": "Apache 2.0",
|
||||
"bugs": {
|
||||
"url": "https://github.com/christkv/myfirstproject/issues"
|
||||
},
|
||||
"homepage": "https://github.com/christkv/myfirstproject"
|
||||
}
|
||||
```
|
||||
|
||||
Save the file and return to the shell or command prompt and use **NPM** to install all the dependencies.
|
||||
|
||||
```
|
||||
npm install
|
||||
```
|
||||
|
||||
You should see **NPM** download a lot of files. Once it's done you'll find all the downloaded packages under the **node_modules** directory.
|
||||
|
||||
Booting up a MongoDB Server
|
||||
---------------------------
|
||||
Let's boot up a MongoDB server instance. Download the right MongoDB version from [MongoDB](http://www.mongodb.org), open a new shell or command line and ensure the **mongod** command is in the shell or command line path. Now let's create a database directory (in our case under **/data**).
|
||||
|
||||
```
|
||||
mongod --dbpath=/data --port 27017
|
||||
```
|
||||
|
||||
You should see the **mongod** process start up and print some status information.
|
||||
|
||||
## Connecting to MongoDB
|
||||
|
||||
Let's create a new **app.js** file that we will use to show the basic CRUD operations using the MongoDB driver.
|
||||
|
||||
First let's add code to connect to the server. Notice that there is no concept of a database here and we use the topology directly to perform the connection.
|
||||
|
||||
```js
|
||||
var Server = require('mongodb-core').Server
|
||||
, assert = require('assert');
|
||||
|
||||
// Set up server connection
|
||||
var server = new Server({
|
||||
host: 'localhost'
|
||||
, port: 27017
|
||||
, reconnect: true
|
||||
, reconnectInterval: 50
|
||||
});
|
||||
|
||||
// Add event listeners
|
||||
server.on('connect', function(_server) {
|
||||
console.log('connected');
|
||||
test.done();
|
||||
});
|
||||
|
||||
server.on('close', function() {
|
||||
console.log('closed');
|
||||
});
|
||||
|
||||
server.on('reconnect', function() {
|
||||
console.log('reconnect');
|
||||
});
|
||||
|
||||
// Start connection
|
||||
server.connect();
|
||||
```
|
||||
|
||||
To connect to a replicaset we would use the `ReplSet` class and for a set of Mongos proxies we use the `Mongos` class. Each topology class offer the same CRUD operations and you operate on the topology directly. Let's look at an example exercising all the different available CRUD operations.
|
||||
|
||||
```js
|
||||
var Server = require('mongodb-core').Server
|
||||
, assert = require('assert');
|
||||
|
||||
// Set up server connection
|
||||
var server = new Server({
|
||||
host: 'localhost'
|
||||
, port: 27017
|
||||
, reconnect: true
|
||||
, reconnectInterval: 50
|
||||
});
|
||||
|
||||
// Add event listeners
|
||||
server.on('connect', function(_server) {
|
||||
console.log('connected');
|
||||
|
||||
// Execute the ismaster command
|
||||
_server.command('system.$cmd', {ismaster: true}, function(err, result) {
|
||||
|
||||
// Perform a document insert
|
||||
_server.insert('myproject.inserts1', [{a:1}, {a:2}], {
|
||||
writeConcern: {w:1}, ordered:true
|
||||
}, function(err, results) {
|
||||
assert.equal(null, err);
|
||||
assert.equal(2, results.result.n);
|
||||
|
||||
// Perform a document update
|
||||
_server.update('myproject.inserts1', [{
|
||||
q: {a: 1}, u: {'$set': {b:1}}
|
||||
}], {
|
||||
writeConcern: {w:1}, ordered:true
|
||||
}, function(err, results) {
|
||||
assert.equal(null, err);
|
||||
assert.equal(1, results.result.n);
|
||||
|
||||
// Remove a document
|
||||
_server.remove('myproject.inserts1', [{
|
||||
q: {a: 1}, limit: 1
|
||||
}], {
|
||||
writeConcern: {w:1}, ordered:true
|
||||
}, function(err, results) {
|
||||
assert.equal(null, err);
|
||||
assert.equal(1, results.result.n);
|
||||
|
||||
// Get a document
|
||||
var cursor = _server.cursor('integration_tests.inserts_example4', {
|
||||
find: 'integration_tests.example4'
|
||||
, query: {a:1}
|
||||
});
|
||||
|
||||
// Get the first document
|
||||
cursor.next(function(err, doc) {
|
||||
assert.equal(null, err);
|
||||
assert.equal(2, doc.a);
|
||||
|
||||
// Execute the ismaster command
|
||||
_server.command("system.$cmd"
|
||||
, {ismaster: true}, function(err, result) {
|
||||
assert.equal(null, err)
|
||||
_server.destroy();
|
||||
});
|
||||
});
|
||||
});
|
||||
});
|
||||
|
||||
test.done();
|
||||
});
|
||||
});
|
||||
|
||||
server.on('close', function() {
|
||||
console.log('closed');
|
||||
});
|
||||
|
||||
server.on('reconnect', function() {
|
||||
console.log('reconnect');
|
||||
});
|
||||
|
||||
// Start connection
|
||||
server.connect();
|
||||
```
|
||||
|
||||
The core driver does not contain any helpers or abstractions only the core crud operations. These consist of the following commands.
|
||||
|
||||
* `insert`, Insert takes an array of 1 or more documents to be inserted against the topology and allows you to specify a write concern and if you wish to execute the inserts in order or out of order.
|
||||
* `update`, Update takes an array of 1 or more update commands to be executed against the server topology and also allows you to specify a write concern and if you wish to execute the updates in order or out of order.
|
||||
* `remove`, Remove takes an array of 1 or more remove commands to be executed against the server topology and also allows you to specify a write concern and if you wish to execute the removes in order or out of order.
|
||||
* `cursor`, Returns you a cursor for either the 'virtual' `find` command, a command that returns a cursor id or a plain cursor id. Read the cursor tutorial for more inn depth coverage.
|
||||
* `command`, Executes a command against MongoDB and returns the result.
|
||||
* `auth`, Authenticates the current topology using a supported authentication scheme.
|
||||
|
||||
The Core Driver is a building block for library builders and is not meant for usage by end users as it lacks a lot of features the end user might need such as automatic buffering of operations when a primary is changing in a replicaset or the db and collections abstraction.
|
||||
|
||||
## Next steps
|
||||
|
||||
The next step is to get more in depth information about how the different aspects of the core driver works and how to leverage them to extend the functionality of the cursors. Please view the tutorials for more detailed information.
|
||||
+41
@@ -0,0 +1,41 @@
|
||||
Mongodb-core uses third-party libraries or other resources that may
|
||||
be distributed under licenses different than the Mongodb-core software.
|
||||
|
||||
In the event that we accidentally failed to list a required notice,
|
||||
please bring it to our attention through any of the ways detailed here:
|
||||
|
||||
mongodb-dev@googlegroups.com
|
||||
|
||||
The attached notices are provided for information only.
|
||||
|
||||
For any licenses that require disclosure of source, sources are available at
|
||||
https://github.com/mongodb/node-mongodb-native.
|
||||
|
||||
1) License Notice for nan.h
|
||||
---------------------------
|
||||
|
||||
The MIT License (MIT)
|
||||
=====================
|
||||
|
||||
Copyright (c) 2016 NAN contributors
|
||||
-----------------------------------
|
||||
|
||||
NAN contributors listed at <https://github.com/nodejs/nan#contributors>
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
this software and associated documentation files (the "Software"), to deal in
|
||||
the Software without restriction, including without limitation the rights to
|
||||
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
|
||||
of the Software, and to permit persons to whom the Software is furnished to
|
||||
do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in all
|
||||
copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
|
||||
IN THE SOFTWARE.
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
{
|
||||
"plugins": ["plugins/markdown", "docs/lib/jsdoc/examples_plugin.js"],
|
||||
"source": {
|
||||
"include": [
|
||||
"test/tests/functional/operation_example_tests.js",
|
||||
"lib/connection/command_result.js",
|
||||
"lib/topologies/mongos.js",
|
||||
"lib/topologies/read_preference.js",
|
||||
"lib/topologies/replset.js",
|
||||
"lib/topologies/server.js",
|
||||
"lib/topologies/replset_state.js",
|
||||
"lib/connection/logger.js",
|
||||
"lib/connection/connection.js",
|
||||
"lib/cursor.js",
|
||||
"lib/error.js",
|
||||
"lib/sessions.js",
|
||||
"lib/transactions.js",
|
||||
"node_modules/bson/lib/bson/binary.js",
|
||||
"node_modules/bson/lib/bson/code.js",
|
||||
"node_modules/bson/lib/bson/db_ref.js",
|
||||
"node_modules/bson/lib/bson/double.js",
|
||||
"node_modules/bson/lib/bson/long.js",
|
||||
"node_modules/bson/lib/bson/objectid.js",
|
||||
"node_modules/bson/lib/bson/symbol.js",
|
||||
"node_modules/bson/lib/bson/timestamp.js",
|
||||
"node_modules/bson/lib/bson/max_key.js",
|
||||
"node_modules/bson/lib/bson/min_key.js"
|
||||
]
|
||||
},
|
||||
"templates": {
|
||||
"cleverLinks": true,
|
||||
"monospaceLinks": true,
|
||||
"default": {
|
||||
"outputSourceFiles" : true
|
||||
},
|
||||
"applicationName": "Node.js MongoDB Driver API",
|
||||
"disqus": true,
|
||||
"googleAnalytics": "UA-29229787-1",
|
||||
"openGraph": {
|
||||
"title": "",
|
||||
"type": "website",
|
||||
"image": "",
|
||||
"site_name": "",
|
||||
"url": ""
|
||||
},
|
||||
"meta": {
|
||||
"title": "",
|
||||
"description": "",
|
||||
"keyword": ""
|
||||
},
|
||||
"linenums": true
|
||||
},
|
||||
"markdown": {
|
||||
"parser": "gfm",
|
||||
"hardwrap": true,
|
||||
"tags": ["examples"]
|
||||
},
|
||||
"examples": {
|
||||
"indent": 4
|
||||
}
|
||||
}
|
||||
+48
@@ -0,0 +1,48 @@
|
||||
'use strict';
|
||||
|
||||
var BSON = require('bson');
|
||||
var require_optional = require('require_optional');
|
||||
const EJSON = require('./lib/utils').retrieveEJSON();
|
||||
|
||||
try {
|
||||
// Attempt to grab the native BSON parser
|
||||
var BSONNative = require_optional('bson-ext');
|
||||
// If we got the native parser, use it instead of the
|
||||
// Javascript one
|
||||
if (BSONNative) {
|
||||
BSON = BSONNative;
|
||||
}
|
||||
} catch (err) {} // eslint-disable-line
|
||||
|
||||
module.exports = {
|
||||
// Errors
|
||||
MongoError: require('./lib/error').MongoError,
|
||||
MongoNetworkError: require('./lib/error').MongoNetworkError,
|
||||
MongoParseError: require('./lib/error').MongoParseError,
|
||||
MongoTimeoutError: require('./lib/error').MongoTimeoutError,
|
||||
MongoWriteConcernError: require('./lib/error').MongoWriteConcernError,
|
||||
mongoErrorContextSymbol: require('./lib/error').mongoErrorContextSymbol,
|
||||
// Core
|
||||
Connection: require('./lib/connection/connection'),
|
||||
Server: require('./lib/topologies/server'),
|
||||
ReplSet: require('./lib/topologies/replset'),
|
||||
Mongos: require('./lib/topologies/mongos'),
|
||||
Logger: require('./lib/connection/logger'),
|
||||
Cursor: require('./lib/cursor'),
|
||||
ReadPreference: require('./lib/topologies/read_preference'),
|
||||
Sessions: require('./lib/sessions'),
|
||||
BSON: BSON,
|
||||
EJSON: EJSON,
|
||||
// Raw operations
|
||||
Query: require('./lib/connection/commands').Query,
|
||||
// Auth mechanisms
|
||||
defaultAuthProviders: require('./lib/auth/defaultAuthProviders').defaultAuthProviders,
|
||||
MongoCR: require('./lib/auth/mongocr'),
|
||||
X509: require('./lib/auth/x509'),
|
||||
Plain: require('./lib/auth/plain'),
|
||||
GSSAPI: require('./lib/auth/gssapi'),
|
||||
ScramSHA1: require('./lib/auth/scram').ScramSHA1,
|
||||
ScramSHA256: require('./lib/auth/scram').ScramSHA256,
|
||||
// Utilities
|
||||
parseConnectionString: require('./lib/uri_parser')
|
||||
};
|
||||
+29
@@ -0,0 +1,29 @@
|
||||
'use strict';
|
||||
|
||||
const MongoCR = require('./mongocr');
|
||||
const X509 = require('./x509');
|
||||
const Plain = require('./plain');
|
||||
const GSSAPI = require('./gssapi');
|
||||
const SSPI = require('./sspi');
|
||||
const ScramSHA1 = require('./scram').ScramSHA1;
|
||||
const ScramSHA256 = require('./scram').ScramSHA256;
|
||||
|
||||
/**
|
||||
* Returns the default authentication providers.
|
||||
*
|
||||
* @param {BSON} bson Bson definition
|
||||
* @returns {Object} a mapping of auth names to auth types
|
||||
*/
|
||||
function defaultAuthProviders(bson) {
|
||||
return {
|
||||
mongocr: new MongoCR(bson),
|
||||
x509: new X509(bson),
|
||||
plain: new Plain(bson),
|
||||
gssapi: new GSSAPI(bson),
|
||||
sspi: new SSPI(bson),
|
||||
'scram-sha-1': new ScramSHA1(bson),
|
||||
'scram-sha-256': new ScramSHA256(bson)
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = { defaultAuthProviders };
|
||||
+374
@@ -0,0 +1,374 @@
|
||||
'use strict';
|
||||
|
||||
const f = require('util').format;
|
||||
const Kerberos = require('../utils').Kerberos;
|
||||
const MongoAuthProcess = require('../utils').MongoAuthProcess;
|
||||
const Query = require('../connection/commands').Query;
|
||||
const MongoError = require('../error').MongoError;
|
||||
|
||||
var AuthSession = function(db, username, password, options) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
this.options = options;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new GSSAPI authentication mechanism
|
||||
* @class
|
||||
* @return {GSSAPI} A cursor instance
|
||||
*/
|
||||
var GSSAPI = function(bson) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
};
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
GSSAPI.prototype.auth = function(server, connections, db, username, password, options, callback) {
|
||||
var self = this;
|
||||
// We don't have the Kerberos library
|
||||
if (Kerberos == null) return callback(new Error('Kerberos library is not installed'));
|
||||
var gssapiServiceName = options['gssapiServiceName'] || 'mongodb';
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
// Execute MongoCR
|
||||
var execute = function(connection) {
|
||||
// Start Auth process for a connection
|
||||
GSSAPIInitialize(
|
||||
self,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
db,
|
||||
gssapiServiceName,
|
||||
server,
|
||||
connection,
|
||||
options,
|
||||
function(err, r) {
|
||||
// Adjust count
|
||||
count = count - 1;
|
||||
|
||||
// If we have an error
|
||||
if (err) {
|
||||
errorObject = err;
|
||||
} else if (r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
} else if (r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
// We have authenticated all connections
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password, options));
|
||||
// Return correct authentication
|
||||
callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using mongocr'));
|
||||
callback(errorObject, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
execute(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// Initialize step
|
||||
var GSSAPIInitialize = function(
|
||||
self,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
gssapiServiceName,
|
||||
server,
|
||||
connection,
|
||||
options,
|
||||
callback
|
||||
) {
|
||||
// Create authenticator
|
||||
var mongo_auth_process = new MongoAuthProcess(
|
||||
connection.host,
|
||||
connection.port,
|
||||
gssapiServiceName,
|
||||
options
|
||||
);
|
||||
|
||||
// Perform initialization
|
||||
mongo_auth_process.init(username, password, function(err) {
|
||||
if (err) return callback(err, false);
|
||||
|
||||
// Perform the first step
|
||||
mongo_auth_process.transition('', function(err, payload) {
|
||||
if (err) return callback(err, false);
|
||||
|
||||
// Call the next db step
|
||||
MongoDBGSSAPIFirstStep(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
);
|
||||
});
|
||||
});
|
||||
};
|
||||
|
||||
//
|
||||
// Perform first step against mongodb
|
||||
var MongoDBGSSAPIFirstStep = function(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
) {
|
||||
// Build the sasl start command
|
||||
var command = {
|
||||
saslStart: 1,
|
||||
mechanism: 'GSSAPI',
|
||||
payload: payload,
|
||||
autoAuthorize: 1
|
||||
};
|
||||
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
// Execute mongodb transition
|
||||
mongo_auth_process.transition(r.result.payload, function(err, payload) {
|
||||
if (err) return callback(err, false);
|
||||
|
||||
// MongoDB API Second Step
|
||||
MongoDBGSSAPISecondStep(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
doc,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
//
|
||||
// Perform first step against mongodb
|
||||
var MongoDBGSSAPISecondStep = function(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
doc,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
) {
|
||||
// Build Authentication command to send to MongoDB
|
||||
var command = {
|
||||
saslContinue: 1,
|
||||
conversationId: doc.conversationId,
|
||||
payload: payload
|
||||
};
|
||||
|
||||
// Execute the command
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
// Call next transition for kerberos
|
||||
mongo_auth_process.transition(doc.payload, function(err, payload) {
|
||||
if (err) return callback(err, false);
|
||||
|
||||
// Call the last and third step
|
||||
MongoDBGSSAPIThirdStep(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
doc,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var MongoDBGSSAPIThirdStep = function(
|
||||
self,
|
||||
mongo_auth_process,
|
||||
payload,
|
||||
doc,
|
||||
db,
|
||||
username,
|
||||
password,
|
||||
authdb,
|
||||
server,
|
||||
connection,
|
||||
callback
|
||||
) {
|
||||
// Build final command
|
||||
var command = {
|
||||
saslContinue: 1,
|
||||
conversationId: doc.conversationId,
|
||||
payload: payload
|
||||
};
|
||||
|
||||
// Execute the command
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
mongo_auth_process.transition(null, function(err) {
|
||||
if (err) return callback(err, null);
|
||||
callback(null, r);
|
||||
});
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
GSSAPI.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
GSSAPI.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
authStore[i].options,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This is a result from a authentication strategy
|
||||
*
|
||||
* @callback authResultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {boolean} result The result of the authentication process
|
||||
*/
|
||||
|
||||
module.exports = GSSAPI;
|
||||
+214
@@ -0,0 +1,214 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
crypto = require('crypto'),
|
||||
Query = require('../connection/commands').Query,
|
||||
MongoError = require('../error').MongoError;
|
||||
|
||||
var AuthSession = function(db, username, password) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new MongoCR authentication mechanism
|
||||
* @class
|
||||
* @return {MongoCR} A cursor instance
|
||||
*/
|
||||
var MongoCR = function(bson) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
MongoCR.prototype.auth = function(server, connections, db, username, password, callback) {
|
||||
var self = this;
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
// Execute MongoCR
|
||||
var executeMongoCR = function(connection) {
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(
|
||||
self.bson,
|
||||
f('%s.$cmd', db),
|
||||
{
|
||||
getnonce: 1
|
||||
},
|
||||
{
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}
|
||||
),
|
||||
function(err, r) {
|
||||
var nonce = null;
|
||||
var key = null;
|
||||
|
||||
// Adjust the number of connections left
|
||||
// Get nonce
|
||||
if (err == null) {
|
||||
nonce = r.result.nonce;
|
||||
// Use node md5 generator
|
||||
var md5 = crypto.createHash('md5');
|
||||
// Generate keys used for authentication
|
||||
md5.update(username + ':mongo:' + password, 'utf8');
|
||||
var hash_password = md5.digest('hex');
|
||||
// Final key
|
||||
md5 = crypto.createHash('md5');
|
||||
md5.update(nonce + username + hash_password, 'utf8');
|
||||
key = md5.digest('hex');
|
||||
}
|
||||
|
||||
// Execute command
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(
|
||||
self.bson,
|
||||
f('%s.$cmd', db),
|
||||
{
|
||||
authenticate: 1,
|
||||
user: username,
|
||||
nonce: nonce,
|
||||
key: key
|
||||
},
|
||||
{
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}
|
||||
),
|
||||
function(err, r) {
|
||||
count = count - 1;
|
||||
|
||||
// If we have an error
|
||||
if (err) {
|
||||
errorObject = err;
|
||||
} else if (r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
} else if (r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
// We have authenticated all connections
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password));
|
||||
// Return correct authentication
|
||||
callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using mongocr'));
|
||||
callback(errorObject, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
executeMongoCR(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
MongoCR.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
MongoCR.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This is a result from a authentication strategy
|
||||
*
|
||||
* @callback authResultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {boolean} result The result of the authentication process
|
||||
*/
|
||||
|
||||
module.exports = MongoCR;
|
||||
+183
@@ -0,0 +1,183 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
retrieveBSON = require('../connection/utils').retrieveBSON,
|
||||
Query = require('../connection/commands').Query,
|
||||
MongoError = require('../error').MongoError;
|
||||
|
||||
var BSON = retrieveBSON(),
|
||||
Binary = BSON.Binary;
|
||||
|
||||
var AuthSession = function(db, username, password) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new Plain authentication mechanism
|
||||
* @class
|
||||
* @return {Plain} A cursor instance
|
||||
*/
|
||||
var Plain = function(bson) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
};
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
Plain.prototype.auth = function(server, connections, db, username, password, callback) {
|
||||
var self = this;
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
// Execute MongoCR
|
||||
var execute = function(connection) {
|
||||
// Create payload
|
||||
var payload = new Binary(f('\x00%s\x00%s', username, password));
|
||||
|
||||
// Let's start the sasl process
|
||||
var command = {
|
||||
saslStart: 1,
|
||||
mechanism: 'PLAIN',
|
||||
payload: payload,
|
||||
autoAuthorize: 1
|
||||
};
|
||||
|
||||
// Let's start the process
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
// Adjust count
|
||||
count = count - 1;
|
||||
|
||||
// If we have an error
|
||||
if (err) {
|
||||
errorObject = err;
|
||||
} else if (r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
} else if (r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
// We have authenticated all connections
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password));
|
||||
// Return correct authentication
|
||||
callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using mongocr'));
|
||||
callback(errorObject, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
execute(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
Plain.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
Plain.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This is a result from a authentication strategy
|
||||
*
|
||||
* @callback authResultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {boolean} result The result of the authentication process
|
||||
*/
|
||||
|
||||
module.exports = Plain;
|
||||
+442
@@ -0,0 +1,442 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
crypto = require('crypto'),
|
||||
retrieveBSON = require('../connection/utils').retrieveBSON,
|
||||
Query = require('../connection/commands').Query,
|
||||
MongoError = require('../error').MongoError,
|
||||
Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
let saslprep;
|
||||
|
||||
try {
|
||||
saslprep = require('saslprep');
|
||||
} catch (e) {
|
||||
// don't do anything;
|
||||
}
|
||||
|
||||
var BSON = retrieveBSON(),
|
||||
Binary = BSON.Binary;
|
||||
|
||||
var AuthSession = function(db, username, password) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
var id = 0;
|
||||
|
||||
/**
|
||||
* Creates a new ScramSHA authentication mechanism
|
||||
* @class
|
||||
* @return {ScramSHA} A cursor instance
|
||||
*/
|
||||
var ScramSHA = function(bson, cryptoMethod) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
this.id = id++;
|
||||
this.cryptoMethod = cryptoMethod || 'sha1';
|
||||
};
|
||||
|
||||
var parsePayload = function(payload) {
|
||||
var dict = {};
|
||||
var parts = payload.split(',');
|
||||
|
||||
for (var i = 0; i < parts.length; i++) {
|
||||
var valueParts = parts[i].split('=');
|
||||
dict[valueParts[0]] = valueParts[1];
|
||||
}
|
||||
|
||||
return dict;
|
||||
};
|
||||
|
||||
var passwordDigest = function(username, password) {
|
||||
if (typeof username !== 'string') throw new MongoError('username must be a string');
|
||||
if (typeof password !== 'string') throw new MongoError('password must be a string');
|
||||
if (password.length === 0) throw new MongoError('password cannot be empty');
|
||||
// Use node md5 generator
|
||||
var md5 = crypto.createHash('md5');
|
||||
// Generate keys used for authentication
|
||||
md5.update(username + ':mongo:' + password, 'utf8');
|
||||
return md5.digest('hex');
|
||||
};
|
||||
|
||||
// XOR two buffers
|
||||
function xor(a, b) {
|
||||
if (!Buffer.isBuffer(a)) a = Buffer.from(a);
|
||||
if (!Buffer.isBuffer(b)) b = Buffer.from(b);
|
||||
const length = Math.max(a.length, b.length);
|
||||
const res = [];
|
||||
|
||||
for (let i = 0; i < length; i += 1) {
|
||||
res.push(a[i] ^ b[i]);
|
||||
}
|
||||
|
||||
return Buffer.from(res).toString('base64');
|
||||
}
|
||||
|
||||
function H(method, text) {
|
||||
return crypto
|
||||
.createHash(method)
|
||||
.update(text)
|
||||
.digest();
|
||||
}
|
||||
|
||||
function HMAC(method, key, text) {
|
||||
return crypto
|
||||
.createHmac(method, key)
|
||||
.update(text)
|
||||
.digest();
|
||||
}
|
||||
|
||||
var _hiCache = {};
|
||||
var _hiCacheCount = 0;
|
||||
var _hiCachePurge = function() {
|
||||
_hiCache = {};
|
||||
_hiCacheCount = 0;
|
||||
};
|
||||
|
||||
const hiLengthMap = {
|
||||
sha256: 32,
|
||||
sha1: 20
|
||||
};
|
||||
|
||||
function HI(data, salt, iterations, cryptoMethod) {
|
||||
// omit the work if already generated
|
||||
const key = [data, salt.toString('base64'), iterations].join('_');
|
||||
if (_hiCache[key] !== undefined) {
|
||||
return _hiCache[key];
|
||||
}
|
||||
|
||||
// generate the salt
|
||||
const saltedData = crypto.pbkdf2Sync(
|
||||
data,
|
||||
salt,
|
||||
iterations,
|
||||
hiLengthMap[cryptoMethod],
|
||||
cryptoMethod
|
||||
);
|
||||
|
||||
// cache a copy to speed up the next lookup, but prevent unbounded cache growth
|
||||
if (_hiCacheCount >= 200) {
|
||||
_hiCachePurge();
|
||||
}
|
||||
|
||||
_hiCache[key] = saltedData;
|
||||
_hiCacheCount += 1;
|
||||
return saltedData;
|
||||
}
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
ScramSHA.prototype.auth = function(server, connections, db, username, password, callback) {
|
||||
var self = this;
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
const cryptoMethod = this.cryptoMethod;
|
||||
let mechanism = 'SCRAM-SHA-1';
|
||||
let processedPassword;
|
||||
|
||||
if (cryptoMethod === 'sha256') {
|
||||
mechanism = 'SCRAM-SHA-256';
|
||||
|
||||
let saslprepFn = (server.s && server.s.saslprep) || saslprep;
|
||||
|
||||
if (saslprepFn) {
|
||||
processedPassword = saslprepFn(password);
|
||||
} else {
|
||||
console.warn('Warning: no saslprep library specified. Passwords will not be sanitized');
|
||||
processedPassword = password;
|
||||
}
|
||||
} else {
|
||||
processedPassword = passwordDigest(username, password);
|
||||
}
|
||||
|
||||
// Execute MongoCR
|
||||
var executeScram = function(connection) {
|
||||
// Clean up the user
|
||||
username = username.replace('=', '=3D').replace(',', '=2C');
|
||||
|
||||
// Create a random nonce
|
||||
var nonce = crypto.randomBytes(24).toString('base64');
|
||||
// var nonce = 'MsQUY9iw0T9fx2MUEz6LZPwGuhVvWAhc'
|
||||
|
||||
// NOTE: This is done b/c Javascript uses UTF-16, but the server is hashing in UTF-8.
|
||||
// Since the username is not sasl-prep-d, we need to do this here.
|
||||
const firstBare = Buffer.concat([
|
||||
Buffer.from('n=', 'utf8'),
|
||||
Buffer.from(username, 'utf8'),
|
||||
Buffer.from(',r=', 'utf8'),
|
||||
Buffer.from(nonce, 'utf8')
|
||||
]);
|
||||
|
||||
// Build command structure
|
||||
var cmd = {
|
||||
saslStart: 1,
|
||||
mechanism: mechanism,
|
||||
payload: new Binary(Buffer.concat([Buffer.from('n,,', 'utf8'), firstBare])),
|
||||
autoAuthorize: 1
|
||||
};
|
||||
|
||||
// Handle the error
|
||||
var handleError = function(err, r) {
|
||||
if (err) {
|
||||
numberOfValidConnections = numberOfValidConnections - 1;
|
||||
errorObject = err;
|
||||
return false;
|
||||
} else if (r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
return false;
|
||||
} else if (r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
return false;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
// Finish up
|
||||
var finish = function(_count, _numberOfValidConnections) {
|
||||
if (_count === 0 && _numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password));
|
||||
// Return correct authentication
|
||||
return callback(null, true);
|
||||
} else if (_count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using scram'));
|
||||
return callback(errorObject, false);
|
||||
}
|
||||
};
|
||||
|
||||
var handleEnd = function(_err, _r) {
|
||||
// Handle any error
|
||||
handleError(_err, _r);
|
||||
// Adjust the number of connections
|
||||
count = count - 1;
|
||||
// Execute the finish
|
||||
finish(count, numberOfValidConnections);
|
||||
};
|
||||
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, f('%s.$cmd', db), cmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
// Do we have an error, handle it
|
||||
if (handleError(err, r) === false) {
|
||||
count = count - 1;
|
||||
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password));
|
||||
// Return correct authentication
|
||||
return callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using scram'));
|
||||
return callback(errorObject, false);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Get the dictionary
|
||||
var dict = parsePayload(r.result.payload.value());
|
||||
|
||||
// Unpack dictionary
|
||||
var iterations = parseInt(dict.i, 10);
|
||||
var salt = dict.s;
|
||||
var rnonce = dict.r;
|
||||
|
||||
// Set up start of proof
|
||||
var withoutProof = f('c=biws,r=%s', rnonce);
|
||||
var saltedPassword = HI(
|
||||
processedPassword,
|
||||
Buffer.from(salt, 'base64'),
|
||||
iterations,
|
||||
cryptoMethod
|
||||
);
|
||||
|
||||
if (iterations && iterations < 4096) {
|
||||
const error = new MongoError(`Server returned an invalid iteration count ${iterations}`);
|
||||
return callback(error, false);
|
||||
}
|
||||
|
||||
// Create the client key
|
||||
const clientKey = HMAC(cryptoMethod, saltedPassword, 'Client Key');
|
||||
|
||||
// Create the stored key
|
||||
const storedKey = H(cryptoMethod, clientKey);
|
||||
|
||||
// Create the authentication message
|
||||
const authMessage = [
|
||||
firstBare,
|
||||
r.result.payload.value().toString('base64'),
|
||||
withoutProof
|
||||
].join(',');
|
||||
|
||||
// Create client signature
|
||||
const clientSignature = HMAC(cryptoMethod, storedKey, authMessage);
|
||||
|
||||
// Create client proof
|
||||
const clientProof = f('p=%s', xor(clientKey, clientSignature));
|
||||
|
||||
// Create client final
|
||||
const clientFinal = [withoutProof, clientProof].join(',');
|
||||
|
||||
// Create continue message
|
||||
const cmd = {
|
||||
saslContinue: 1,
|
||||
conversationId: r.result.conversationId,
|
||||
payload: new Binary(Buffer.from(clientFinal))
|
||||
};
|
||||
|
||||
//
|
||||
// Execute sasl continue
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, f('%s.$cmd', db), cmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (r && r.result.done === false) {
|
||||
var cmd = {
|
||||
saslContinue: 1,
|
||||
conversationId: r.result.conversationId,
|
||||
payload: Buffer.alloc(0)
|
||||
};
|
||||
|
||||
// Write the commmand on the connection
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, f('%s.$cmd', db), cmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
handleEnd(err, r);
|
||||
}
|
||||
);
|
||||
} else {
|
||||
handleEnd(err, r);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
executeScram(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
ScramSHA.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
ScramSHA.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
// No connections
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
class ScramSHA1 extends ScramSHA {
|
||||
constructor(bson) {
|
||||
super(bson, 'sha1');
|
||||
}
|
||||
}
|
||||
|
||||
class ScramSHA256 extends ScramSHA {
|
||||
constructor(bson) {
|
||||
super(bson, 'sha256');
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { ScramSHA1, ScramSHA256 };
|
||||
+294
@@ -0,0 +1,294 @@
|
||||
'use strict';
|
||||
|
||||
const f = require('util').format;
|
||||
const Kerberos = require('../utils').Kerberos;
|
||||
const MongoAuthProcess = require('../utils').MongoAuthProcess;
|
||||
const Query = require('../connection/commands').Query;
|
||||
const MongoError = require('../error').MongoError;
|
||||
|
||||
var AuthSession = function(db, username, password, options) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
this.options = options;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new SSPI authentication mechanism
|
||||
* @class
|
||||
* @return {SSPI} A cursor instance
|
||||
*/
|
||||
var SSPI = function(bson) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
};
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
SSPI.prototype.auth = function(server, connections, db, username, password, options, callback) {
|
||||
var self = this;
|
||||
// We don't have the Kerberos library
|
||||
if (Kerberos == null) return callback(new Error('Kerberos library is not installed'));
|
||||
var gssapiServiceName = options['gssapiServiceName'] || 'mongodb';
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
// Execute MongoCR
|
||||
var execute = function(connection) {
|
||||
// Start Auth process for a connection
|
||||
SSIPAuthenticate(
|
||||
self,
|
||||
username,
|
||||
password,
|
||||
gssapiServiceName,
|
||||
server,
|
||||
connection,
|
||||
options,
|
||||
function(err, r) {
|
||||
// Adjust count
|
||||
count = count - 1;
|
||||
|
||||
// If we have an error
|
||||
if (err) {
|
||||
errorObject = err;
|
||||
} else if (r && typeof r === 'object' && r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
} else if (r && typeof r === 'object' && r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
// We have authenticated all connections
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password, options));
|
||||
// Return correct authentication
|
||||
callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using mongocr'));
|
||||
callback(errorObject, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
execute(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
var SSIPAuthenticate = function(
|
||||
self,
|
||||
username,
|
||||
password,
|
||||
gssapiServiceName,
|
||||
server,
|
||||
connection,
|
||||
options,
|
||||
callback
|
||||
) {
|
||||
// Build Authentication command to send to MongoDB
|
||||
var command = {
|
||||
saslStart: 1,
|
||||
mechanism: 'GSSAPI',
|
||||
payload: '',
|
||||
autoAuthorize: 1
|
||||
};
|
||||
|
||||
// Create authenticator
|
||||
var mongo_auth_process = new MongoAuthProcess(
|
||||
connection.host,
|
||||
connection.port,
|
||||
gssapiServiceName,
|
||||
options
|
||||
);
|
||||
|
||||
// Execute first sasl step
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
|
||||
mongo_auth_process.init(username, password, function(err) {
|
||||
if (err) return callback(err);
|
||||
|
||||
mongo_auth_process.transition(doc.payload, function(err, payload) {
|
||||
if (err) return callback(err);
|
||||
|
||||
// Perform the next step against mongod
|
||||
var command = {
|
||||
saslContinue: 1,
|
||||
conversationId: doc.conversationId,
|
||||
payload: payload
|
||||
};
|
||||
|
||||
// Execute the command
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
|
||||
mongo_auth_process.transition(doc.payload, function(err, payload) {
|
||||
if (err) return callback(err);
|
||||
|
||||
// Perform the next step against mongod
|
||||
var command = {
|
||||
saslContinue: 1,
|
||||
conversationId: doc.conversationId,
|
||||
payload: payload
|
||||
};
|
||||
|
||||
// Execute the command
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
|
||||
mongo_auth_process.transition(doc.payload, function(err, payload) {
|
||||
// Perform the next step against mongod
|
||||
var command = {
|
||||
saslContinue: 1,
|
||||
conversationId: doc.conversationId,
|
||||
payload: payload
|
||||
};
|
||||
|
||||
// Execute the command
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
if (err) return callback(err, false);
|
||||
var doc = r.result;
|
||||
|
||||
if (doc.done) return callback(null, true);
|
||||
callback(new Error('Authentication failed'), false);
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
});
|
||||
}
|
||||
);
|
||||
});
|
||||
});
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
SSPI.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
SSPI.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
authStore[i].options,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This is a result from a authentication strategy
|
||||
*
|
||||
* @callback authResultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {boolean} result The result of the authentication process
|
||||
*/
|
||||
|
||||
module.exports = SSPI;
|
||||
+179
@@ -0,0 +1,179 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
Query = require('../connection/commands').Query,
|
||||
MongoError = require('../error').MongoError;
|
||||
|
||||
var AuthSession = function(db, username, password) {
|
||||
this.db = db;
|
||||
this.username = username;
|
||||
this.password = password;
|
||||
};
|
||||
|
||||
AuthSession.prototype.equal = function(session) {
|
||||
return (
|
||||
session.db === this.db &&
|
||||
session.username === this.username &&
|
||||
session.password === this.password
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates a new X509 authentication mechanism
|
||||
* @class
|
||||
* @return {X509} A cursor instance
|
||||
*/
|
||||
var X509 = function(bson) {
|
||||
this.bson = bson;
|
||||
this.authStore = [];
|
||||
};
|
||||
|
||||
/**
|
||||
* Authenticate
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {string} db Name of the database
|
||||
* @param {string} username Username
|
||||
* @param {string} password Password
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
X509.prototype.auth = function(server, connections, db, username, password, callback) {
|
||||
var self = this;
|
||||
// Total connections
|
||||
var count = connections.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
|
||||
// Valid connections
|
||||
var numberOfValidConnections = 0;
|
||||
var errorObject = null;
|
||||
|
||||
// For each connection we need to authenticate
|
||||
while (connections.length > 0) {
|
||||
// Execute MongoCR
|
||||
var execute = function(connection) {
|
||||
// Let's start the sasl process
|
||||
var command = {
|
||||
authenticate: 1,
|
||||
mechanism: 'MONGODB-X509'
|
||||
};
|
||||
|
||||
// Add username if specified
|
||||
if (username) {
|
||||
command.user = username;
|
||||
}
|
||||
|
||||
// Let's start the process
|
||||
server(
|
||||
connection,
|
||||
new Query(self.bson, '$external.$cmd', command, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1
|
||||
}),
|
||||
function(err, r) {
|
||||
// Adjust count
|
||||
count = count - 1;
|
||||
|
||||
// If we have an error
|
||||
if (err) {
|
||||
errorObject = err;
|
||||
} else if (r.result['$err']) {
|
||||
errorObject = r.result;
|
||||
} else if (r.result['errmsg']) {
|
||||
errorObject = r.result;
|
||||
} else {
|
||||
numberOfValidConnections = numberOfValidConnections + 1;
|
||||
}
|
||||
|
||||
// We have authenticated all connections
|
||||
if (count === 0 && numberOfValidConnections > 0) {
|
||||
// Store the auth details
|
||||
addAuthSession(self.authStore, new AuthSession(db, username, password));
|
||||
// Return correct authentication
|
||||
callback(null, true);
|
||||
} else if (count === 0) {
|
||||
if (errorObject == null)
|
||||
errorObject = new MongoError(f('failed to authenticate using mongocr'));
|
||||
callback(errorObject, false);
|
||||
}
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
var _execute = function(_connection) {
|
||||
process.nextTick(function() {
|
||||
execute(_connection);
|
||||
});
|
||||
};
|
||||
|
||||
_execute(connections.shift());
|
||||
}
|
||||
};
|
||||
|
||||
// Add to store only if it does not exist
|
||||
var addAuthSession = function(authStore, session) {
|
||||
var found = false;
|
||||
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
if (authStore[i].equal(session)) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) authStore.push(session);
|
||||
};
|
||||
|
||||
/**
|
||||
* Remove authStore credentials
|
||||
* @method
|
||||
* @param {string} db Name of database we are removing authStore details about
|
||||
* @return {object}
|
||||
*/
|
||||
X509.prototype.logout = function(dbName) {
|
||||
this.authStore = this.authStore.filter(function(x) {
|
||||
return x.db !== dbName;
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Re authenticate pool
|
||||
* @method
|
||||
* @param {{Server}|{ReplSet}|{Mongos}} server Topology the authentication method is being called on
|
||||
* @param {[]Connections} connections Connections to authenticate using this authenticator
|
||||
* @param {authResultCallback} callback The callback to return the result from the authentication
|
||||
* @return {object}
|
||||
*/
|
||||
X509.prototype.reauthenticate = function(server, connections, callback) {
|
||||
var authStore = this.authStore.slice(0);
|
||||
var count = authStore.length;
|
||||
if (count === 0) return callback(null, null);
|
||||
// Iterate over all the auth details stored
|
||||
for (var i = 0; i < authStore.length; i++) {
|
||||
this.auth(
|
||||
server,
|
||||
connections,
|
||||
authStore[i].db,
|
||||
authStore[i].username,
|
||||
authStore[i].password,
|
||||
function(err) {
|
||||
count = count - 1;
|
||||
// Done re-authenticating
|
||||
if (count === 0) {
|
||||
callback(err, null);
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* This is a result from a authentication strategy
|
||||
*
|
||||
* @callback authResultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {boolean} result The result of the authentication process
|
||||
*/
|
||||
|
||||
module.exports = X509;
|
||||
+223
@@ -0,0 +1,223 @@
|
||||
'use strict';
|
||||
const KillCursor = require('../connection/commands').KillCursor;
|
||||
const GetMore = require('../connection/commands').GetMore;
|
||||
const calculateDurationInMs = require('../utils').calculateDurationInMs;
|
||||
|
||||
/** Commands that we want to redact because of the sensitive nature of their contents */
|
||||
const SENSITIVE_COMMANDS = new Set([
|
||||
'authenticate',
|
||||
'saslStart',
|
||||
'saslContinue',
|
||||
'getnonce',
|
||||
'createUser',
|
||||
'updateUser',
|
||||
'copydbgetnonce',
|
||||
'copydbsaslstart',
|
||||
'copydb'
|
||||
]);
|
||||
|
||||
// helper methods
|
||||
const extractCommandName = command => Object.keys(command)[0];
|
||||
const namespace = command => command.ns;
|
||||
const databaseName = command => command.ns.split('.')[0];
|
||||
const collectionName = command => command.ns.split('.')[1];
|
||||
const generateConnectionId = pool => `${pool.options.host}:${pool.options.port}`;
|
||||
const maybeRedact = (commandName, result) => (SENSITIVE_COMMANDS.has(commandName) ? {} : result);
|
||||
|
||||
const LEGACY_FIND_QUERY_MAP = {
|
||||
$query: 'filter',
|
||||
$orderby: 'sort',
|
||||
$hint: 'hint',
|
||||
$comment: 'comment',
|
||||
$maxScan: 'maxScan',
|
||||
$max: 'max',
|
||||
$min: 'min',
|
||||
$returnKey: 'returnKey',
|
||||
$showDiskLoc: 'showRecordId',
|
||||
$maxTimeMS: 'maxTimeMS',
|
||||
$snapshot: 'snapshot'
|
||||
};
|
||||
|
||||
const LEGACY_FIND_OPTIONS_MAP = {
|
||||
numberToSkip: 'skip',
|
||||
numberToReturn: 'batchSize',
|
||||
returnFieldsSelector: 'projection'
|
||||
};
|
||||
|
||||
const OP_QUERY_KEYS = [
|
||||
'tailable',
|
||||
'oplogReplay',
|
||||
'noCursorTimeout',
|
||||
'awaitData',
|
||||
'partial',
|
||||
'exhaust'
|
||||
];
|
||||
|
||||
/**
|
||||
* Extract the actual command from the query, possibly upconverting if it's a legacy
|
||||
* format
|
||||
*
|
||||
* @param {Object} command the command
|
||||
*/
|
||||
const extractCommand = command => {
|
||||
if (command instanceof GetMore) {
|
||||
return {
|
||||
getMore: command.cursorId,
|
||||
collection: collectionName(command),
|
||||
batchSize: command.numberToReturn
|
||||
};
|
||||
}
|
||||
|
||||
if (command instanceof KillCursor) {
|
||||
return {
|
||||
killCursors: collectionName(command),
|
||||
cursors: command.cursorIds
|
||||
};
|
||||
}
|
||||
|
||||
if (command.query && command.query.$query) {
|
||||
// upconvert legacy find command
|
||||
const result = { find: collectionName(command) };
|
||||
Object.keys(LEGACY_FIND_QUERY_MAP).forEach(key => {
|
||||
if (typeof command.query[key] !== 'undefined')
|
||||
result[LEGACY_FIND_QUERY_MAP[key]] = command.query[key];
|
||||
});
|
||||
|
||||
Object.keys(LEGACY_FIND_OPTIONS_MAP).forEach(key => {
|
||||
if (typeof command.options[key] !== 'undefined')
|
||||
result[LEGACY_FIND_OPTIONS_MAP[key]] = command.options[key];
|
||||
});
|
||||
|
||||
OP_QUERY_KEYS.forEach(key => {
|
||||
if (command[key]) result[key] = command[key];
|
||||
});
|
||||
|
||||
if (typeof command.pre32Limit !== 'undefined') {
|
||||
result.limit = command.pre32Limit;
|
||||
}
|
||||
|
||||
if (command.query.$explain) {
|
||||
return { explain: result };
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
return command.query ? command.query : command;
|
||||
};
|
||||
|
||||
const extractReply = (command, reply) => {
|
||||
if (command instanceof GetMore) {
|
||||
return {
|
||||
ok: 1,
|
||||
cursor: {
|
||||
id: reply.message.cursorId,
|
||||
ns: namespace(command),
|
||||
nextBatch: reply.message.documents
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
if (command instanceof KillCursor) {
|
||||
return {
|
||||
ok: 1,
|
||||
cursorsUnknown: command.cursorIds
|
||||
};
|
||||
}
|
||||
|
||||
// is this a legacy find command?
|
||||
if (command.query && typeof command.query.$query !== 'undefined') {
|
||||
return {
|
||||
ok: 1,
|
||||
cursor: {
|
||||
id: reply.message.cursorId,
|
||||
ns: namespace(command),
|
||||
firstBatch: reply.message.documents
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
return reply.result;
|
||||
};
|
||||
|
||||
/** An event indicating the start of a given command */
|
||||
class CommandStartedEvent {
|
||||
/**
|
||||
* Create a started event
|
||||
*
|
||||
* @param {Pool} pool the pool that originated the command
|
||||
* @param {Object} command the command
|
||||
*/
|
||||
constructor(pool, command) {
|
||||
const cmd = extractCommand(command);
|
||||
const commandName = extractCommandName(cmd);
|
||||
|
||||
// NOTE: remove in major revision, this is not spec behavior
|
||||
if (SENSITIVE_COMMANDS.has(commandName)) {
|
||||
this.commandObj = {};
|
||||
this.commandObj[commandName] = true;
|
||||
}
|
||||
|
||||
Object.assign(this, {
|
||||
command: cmd,
|
||||
databaseName: databaseName(command),
|
||||
commandName,
|
||||
requestId: command.requestId,
|
||||
connectionId: generateConnectionId(pool)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** An event indicating the success of a given command */
|
||||
class CommandSucceededEvent {
|
||||
/**
|
||||
* Create a succeeded event
|
||||
*
|
||||
* @param {Pool} pool the pool that originated the command
|
||||
* @param {Object} command the command
|
||||
* @param {Object} reply the reply for this command from the server
|
||||
* @param {Array} started a high resolution tuple timestamp of when the command was first sent, to calculate duration
|
||||
*/
|
||||
constructor(pool, command, reply, started) {
|
||||
const cmd = extractCommand(command);
|
||||
const commandName = extractCommandName(cmd);
|
||||
|
||||
Object.assign(this, {
|
||||
duration: calculateDurationInMs(started),
|
||||
commandName,
|
||||
reply: maybeRedact(commandName, extractReply(command, reply)),
|
||||
requestId: command.requestId,
|
||||
connectionId: generateConnectionId(pool)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/** An event indicating the failure of a given command */
|
||||
class CommandFailedEvent {
|
||||
/**
|
||||
* Create a failure event
|
||||
*
|
||||
* @param {Pool} pool the pool that originated the command
|
||||
* @param {Object} command the command
|
||||
* @param {MongoError|Object} error the generated error or a server error response
|
||||
* @param {Array} started a high resolution tuple timestamp of when the command was first sent, to calculate duration
|
||||
*/
|
||||
constructor(pool, command, error, started) {
|
||||
const cmd = extractCommand(command);
|
||||
const commandName = extractCommandName(cmd);
|
||||
|
||||
Object.assign(this, {
|
||||
duration: calculateDurationInMs(started),
|
||||
commandName,
|
||||
failure: maybeRedact(commandName, error),
|
||||
requestId: command.requestId,
|
||||
connectionId: generateConnectionId(pool)
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
CommandStartedEvent,
|
||||
CommandSucceededEvent,
|
||||
CommandFailedEvent
|
||||
};
|
||||
+34
@@ -0,0 +1,34 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Creates a new CommandResult instance
|
||||
* @class
|
||||
* @param {object} result CommandResult object
|
||||
* @param {Connection} connection A connection instance associated with this result
|
||||
* @return {CommandResult} A cursor instance
|
||||
*/
|
||||
var CommandResult = function(result, connection, message) {
|
||||
this.result = result;
|
||||
this.connection = connection;
|
||||
this.message = message;
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert CommandResult to JSON
|
||||
* @method
|
||||
* @return {object}
|
||||
*/
|
||||
CommandResult.prototype.toJSON = function() {
|
||||
return this.result;
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert CommandResult to String representation
|
||||
* @method
|
||||
* @return {string}
|
||||
*/
|
||||
CommandResult.prototype.toString = function() {
|
||||
return JSON.stringify(this.toJSON());
|
||||
};
|
||||
|
||||
module.exports = CommandResult;
|
||||
+549
@@ -0,0 +1,549 @@
|
||||
'use strict';
|
||||
|
||||
var retrieveBSON = require('./utils').retrieveBSON;
|
||||
var BSON = retrieveBSON();
|
||||
var Long = BSON.Long;
|
||||
const MongoError = require('../error').MongoError;
|
||||
const Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
// Incrementing request id
|
||||
var _requestId = 0;
|
||||
|
||||
// Wire command operation ids
|
||||
var opcodes = require('../wireprotocol/shared').opcodes;
|
||||
|
||||
// Query flags
|
||||
var OPTS_TAILABLE_CURSOR = 2;
|
||||
var OPTS_SLAVE = 4;
|
||||
var OPTS_OPLOG_REPLAY = 8;
|
||||
var OPTS_NO_CURSOR_TIMEOUT = 16;
|
||||
var OPTS_AWAIT_DATA = 32;
|
||||
var OPTS_EXHAUST = 64;
|
||||
var OPTS_PARTIAL = 128;
|
||||
|
||||
// Response flags
|
||||
var CURSOR_NOT_FOUND = 0;
|
||||
var QUERY_FAILURE = 2;
|
||||
var SHARD_CONFIG_STALE = 4;
|
||||
var AWAIT_CAPABLE = 8;
|
||||
|
||||
/**************************************************************
|
||||
* QUERY
|
||||
**************************************************************/
|
||||
var Query = function(bson, ns, query, options) {
|
||||
var self = this;
|
||||
// Basic options needed to be passed in
|
||||
if (ns == null) throw new Error('ns must be specified for query');
|
||||
if (query == null) throw new Error('query must be specified for query');
|
||||
|
||||
// Validate that we are not passing 0x00 in the collection name
|
||||
if (ns.indexOf('\x00') !== -1) {
|
||||
throw new Error('namespace cannot contain a null character');
|
||||
}
|
||||
|
||||
// Basic options
|
||||
this.bson = bson;
|
||||
this.ns = ns;
|
||||
this.query = query;
|
||||
|
||||
// Ensure empty options
|
||||
this.options = options || {};
|
||||
|
||||
// Additional options
|
||||
this.numberToSkip = options.numberToSkip || 0;
|
||||
this.numberToReturn = options.numberToReturn || 0;
|
||||
this.returnFieldSelector = options.returnFieldSelector || null;
|
||||
this.requestId = Query.getRequestId();
|
||||
|
||||
// special case for pre-3.2 find commands, delete ASAP
|
||||
this.pre32Limit = options.pre32Limit;
|
||||
|
||||
// Serialization option
|
||||
this.serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
this.ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
|
||||
this.maxBsonSize = options.maxBsonSize || 1024 * 1024 * 16;
|
||||
this.checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : true;
|
||||
this.batchSize = self.numberToReturn;
|
||||
|
||||
// Flags
|
||||
this.tailable = false;
|
||||
this.slaveOk = typeof options.slaveOk === 'boolean' ? options.slaveOk : false;
|
||||
this.oplogReplay = false;
|
||||
this.noCursorTimeout = false;
|
||||
this.awaitData = false;
|
||||
this.exhaust = false;
|
||||
this.partial = false;
|
||||
};
|
||||
|
||||
//
|
||||
// Assign a new request Id
|
||||
Query.prototype.incRequestId = function() {
|
||||
this.requestId = _requestId++;
|
||||
};
|
||||
|
||||
//
|
||||
// Assign a new request Id
|
||||
Query.nextRequestId = function() {
|
||||
return _requestId + 1;
|
||||
};
|
||||
|
||||
//
|
||||
// Uses a single allocated buffer for the process, avoiding multiple memory allocations
|
||||
Query.prototype.toBin = function() {
|
||||
var self = this;
|
||||
var buffers = [];
|
||||
var projection = null;
|
||||
|
||||
// Set up the flags
|
||||
var flags = 0;
|
||||
if (this.tailable) {
|
||||
flags |= OPTS_TAILABLE_CURSOR;
|
||||
}
|
||||
|
||||
if (this.slaveOk) {
|
||||
flags |= OPTS_SLAVE;
|
||||
}
|
||||
|
||||
if (this.oplogReplay) {
|
||||
flags |= OPTS_OPLOG_REPLAY;
|
||||
}
|
||||
|
||||
if (this.noCursorTimeout) {
|
||||
flags |= OPTS_NO_CURSOR_TIMEOUT;
|
||||
}
|
||||
|
||||
if (this.awaitData) {
|
||||
flags |= OPTS_AWAIT_DATA;
|
||||
}
|
||||
|
||||
if (this.exhaust) {
|
||||
flags |= OPTS_EXHAUST;
|
||||
}
|
||||
|
||||
if (this.partial) {
|
||||
flags |= OPTS_PARTIAL;
|
||||
}
|
||||
|
||||
// If batchSize is different to self.numberToReturn
|
||||
if (self.batchSize !== self.numberToReturn) self.numberToReturn = self.batchSize;
|
||||
|
||||
// Allocate write protocol header buffer
|
||||
var header = Buffer.alloc(
|
||||
4 * 4 + // Header
|
||||
4 + // Flags
|
||||
Buffer.byteLength(self.ns) +
|
||||
1 + // namespace
|
||||
4 + // numberToSkip
|
||||
4 // numberToReturn
|
||||
);
|
||||
|
||||
// Add header to buffers
|
||||
buffers.push(header);
|
||||
|
||||
// Serialize the query
|
||||
var query = self.bson.serialize(this.query, {
|
||||
checkKeys: this.checkKeys,
|
||||
serializeFunctions: this.serializeFunctions,
|
||||
ignoreUndefined: this.ignoreUndefined
|
||||
});
|
||||
|
||||
// Add query document
|
||||
buffers.push(query);
|
||||
|
||||
if (self.returnFieldSelector && Object.keys(self.returnFieldSelector).length > 0) {
|
||||
// Serialize the projection document
|
||||
projection = self.bson.serialize(this.returnFieldSelector, {
|
||||
checkKeys: this.checkKeys,
|
||||
serializeFunctions: this.serializeFunctions,
|
||||
ignoreUndefined: this.ignoreUndefined
|
||||
});
|
||||
// Add projection document
|
||||
buffers.push(projection);
|
||||
}
|
||||
|
||||
// Total message size
|
||||
var totalLength = header.length + query.length + (projection ? projection.length : 0);
|
||||
|
||||
// Set up the index
|
||||
var index = 4;
|
||||
|
||||
// Write total document length
|
||||
header[3] = (totalLength >> 24) & 0xff;
|
||||
header[2] = (totalLength >> 16) & 0xff;
|
||||
header[1] = (totalLength >> 8) & 0xff;
|
||||
header[0] = totalLength & 0xff;
|
||||
|
||||
// Write header information requestId
|
||||
header[index + 3] = (this.requestId >> 24) & 0xff;
|
||||
header[index + 2] = (this.requestId >> 16) & 0xff;
|
||||
header[index + 1] = (this.requestId >> 8) & 0xff;
|
||||
header[index] = this.requestId & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write header information responseTo
|
||||
header[index + 3] = (0 >> 24) & 0xff;
|
||||
header[index + 2] = (0 >> 16) & 0xff;
|
||||
header[index + 1] = (0 >> 8) & 0xff;
|
||||
header[index] = 0 & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write header information OP_QUERY
|
||||
header[index + 3] = (opcodes.OP_QUERY >> 24) & 0xff;
|
||||
header[index + 2] = (opcodes.OP_QUERY >> 16) & 0xff;
|
||||
header[index + 1] = (opcodes.OP_QUERY >> 8) & 0xff;
|
||||
header[index] = opcodes.OP_QUERY & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write header information flags
|
||||
header[index + 3] = (flags >> 24) & 0xff;
|
||||
header[index + 2] = (flags >> 16) & 0xff;
|
||||
header[index + 1] = (flags >> 8) & 0xff;
|
||||
header[index] = flags & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write collection name
|
||||
index = index + header.write(this.ns, index, 'utf8') + 1;
|
||||
header[index - 1] = 0;
|
||||
|
||||
// Write header information flags numberToSkip
|
||||
header[index + 3] = (this.numberToSkip >> 24) & 0xff;
|
||||
header[index + 2] = (this.numberToSkip >> 16) & 0xff;
|
||||
header[index + 1] = (this.numberToSkip >> 8) & 0xff;
|
||||
header[index] = this.numberToSkip & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write header information flags numberToReturn
|
||||
header[index + 3] = (this.numberToReturn >> 24) & 0xff;
|
||||
header[index + 2] = (this.numberToReturn >> 16) & 0xff;
|
||||
header[index + 1] = (this.numberToReturn >> 8) & 0xff;
|
||||
header[index] = this.numberToReturn & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Return the buffers
|
||||
return buffers;
|
||||
};
|
||||
|
||||
Query.getRequestId = function() {
|
||||
return ++_requestId;
|
||||
};
|
||||
|
||||
/**************************************************************
|
||||
* GETMORE
|
||||
**************************************************************/
|
||||
var GetMore = function(bson, ns, cursorId, opts) {
|
||||
opts = opts || {};
|
||||
this.numberToReturn = opts.numberToReturn || 0;
|
||||
this.requestId = _requestId++;
|
||||
this.bson = bson;
|
||||
this.ns = ns;
|
||||
this.cursorId = cursorId;
|
||||
};
|
||||
|
||||
//
|
||||
// Uses a single allocated buffer for the process, avoiding multiple memory allocations
|
||||
GetMore.prototype.toBin = function() {
|
||||
var length = 4 + Buffer.byteLength(this.ns) + 1 + 4 + 8 + 4 * 4;
|
||||
// Create command buffer
|
||||
var index = 0;
|
||||
// Allocate buffer
|
||||
var _buffer = Buffer.alloc(length);
|
||||
|
||||
// Write header information
|
||||
// index = write32bit(index, _buffer, length);
|
||||
_buffer[index + 3] = (length >> 24) & 0xff;
|
||||
_buffer[index + 2] = (length >> 16) & 0xff;
|
||||
_buffer[index + 1] = (length >> 8) & 0xff;
|
||||
_buffer[index] = length & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, requestId);
|
||||
_buffer[index + 3] = (this.requestId >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.requestId >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.requestId >> 8) & 0xff;
|
||||
_buffer[index] = this.requestId & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, 0);
|
||||
_buffer[index + 3] = (0 >> 24) & 0xff;
|
||||
_buffer[index + 2] = (0 >> 16) & 0xff;
|
||||
_buffer[index + 1] = (0 >> 8) & 0xff;
|
||||
_buffer[index] = 0 & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, OP_GETMORE);
|
||||
_buffer[index + 3] = (opcodes.OP_GETMORE >> 24) & 0xff;
|
||||
_buffer[index + 2] = (opcodes.OP_GETMORE >> 16) & 0xff;
|
||||
_buffer[index + 1] = (opcodes.OP_GETMORE >> 8) & 0xff;
|
||||
_buffer[index] = opcodes.OP_GETMORE & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, 0);
|
||||
_buffer[index + 3] = (0 >> 24) & 0xff;
|
||||
_buffer[index + 2] = (0 >> 16) & 0xff;
|
||||
_buffer[index + 1] = (0 >> 8) & 0xff;
|
||||
_buffer[index] = 0 & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write collection name
|
||||
index = index + _buffer.write(this.ns, index, 'utf8') + 1;
|
||||
_buffer[index - 1] = 0;
|
||||
|
||||
// Write batch size
|
||||
// index = write32bit(index, _buffer, numberToReturn);
|
||||
_buffer[index + 3] = (this.numberToReturn >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.numberToReturn >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.numberToReturn >> 8) & 0xff;
|
||||
_buffer[index] = this.numberToReturn & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write cursor id
|
||||
// index = write32bit(index, _buffer, cursorId.getLowBits());
|
||||
_buffer[index + 3] = (this.cursorId.getLowBits() >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.cursorId.getLowBits() >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.cursorId.getLowBits() >> 8) & 0xff;
|
||||
_buffer[index] = this.cursorId.getLowBits() & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, cursorId.getHighBits());
|
||||
_buffer[index + 3] = (this.cursorId.getHighBits() >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.cursorId.getHighBits() >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.cursorId.getHighBits() >> 8) & 0xff;
|
||||
_buffer[index] = this.cursorId.getHighBits() & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Return buffer
|
||||
return _buffer;
|
||||
};
|
||||
|
||||
/**************************************************************
|
||||
* KILLCURSOR
|
||||
**************************************************************/
|
||||
var KillCursor = function(bson, ns, cursorIds) {
|
||||
this.ns = ns;
|
||||
this.requestId = _requestId++;
|
||||
this.cursorIds = cursorIds;
|
||||
};
|
||||
|
||||
//
|
||||
// Uses a single allocated buffer for the process, avoiding multiple memory allocations
|
||||
KillCursor.prototype.toBin = function() {
|
||||
var length = 4 + 4 + 4 * 4 + this.cursorIds.length * 8;
|
||||
|
||||
// Create command buffer
|
||||
var index = 0;
|
||||
var _buffer = Buffer.alloc(length);
|
||||
|
||||
// Write header information
|
||||
// index = write32bit(index, _buffer, length);
|
||||
_buffer[index + 3] = (length >> 24) & 0xff;
|
||||
_buffer[index + 2] = (length >> 16) & 0xff;
|
||||
_buffer[index + 1] = (length >> 8) & 0xff;
|
||||
_buffer[index] = length & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, requestId);
|
||||
_buffer[index + 3] = (this.requestId >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.requestId >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.requestId >> 8) & 0xff;
|
||||
_buffer[index] = this.requestId & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, 0);
|
||||
_buffer[index + 3] = (0 >> 24) & 0xff;
|
||||
_buffer[index + 2] = (0 >> 16) & 0xff;
|
||||
_buffer[index + 1] = (0 >> 8) & 0xff;
|
||||
_buffer[index] = 0 & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, OP_KILL_CURSORS);
|
||||
_buffer[index + 3] = (opcodes.OP_KILL_CURSORS >> 24) & 0xff;
|
||||
_buffer[index + 2] = (opcodes.OP_KILL_CURSORS >> 16) & 0xff;
|
||||
_buffer[index + 1] = (opcodes.OP_KILL_CURSORS >> 8) & 0xff;
|
||||
_buffer[index] = opcodes.OP_KILL_CURSORS & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, 0);
|
||||
_buffer[index + 3] = (0 >> 24) & 0xff;
|
||||
_buffer[index + 2] = (0 >> 16) & 0xff;
|
||||
_buffer[index + 1] = (0 >> 8) & 0xff;
|
||||
_buffer[index] = 0 & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write batch size
|
||||
// index = write32bit(index, _buffer, this.cursorIds.length);
|
||||
_buffer[index + 3] = (this.cursorIds.length >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.cursorIds.length >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.cursorIds.length >> 8) & 0xff;
|
||||
_buffer[index] = this.cursorIds.length & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// Write all the cursor ids into the array
|
||||
for (var i = 0; i < this.cursorIds.length; i++) {
|
||||
// Write cursor id
|
||||
// index = write32bit(index, _buffer, cursorIds[i].getLowBits());
|
||||
_buffer[index + 3] = (this.cursorIds[i].getLowBits() >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.cursorIds[i].getLowBits() >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.cursorIds[i].getLowBits() >> 8) & 0xff;
|
||||
_buffer[index] = this.cursorIds[i].getLowBits() & 0xff;
|
||||
index = index + 4;
|
||||
|
||||
// index = write32bit(index, _buffer, cursorIds[i].getHighBits());
|
||||
_buffer[index + 3] = (this.cursorIds[i].getHighBits() >> 24) & 0xff;
|
||||
_buffer[index + 2] = (this.cursorIds[i].getHighBits() >> 16) & 0xff;
|
||||
_buffer[index + 1] = (this.cursorIds[i].getHighBits() >> 8) & 0xff;
|
||||
_buffer[index] = this.cursorIds[i].getHighBits() & 0xff;
|
||||
index = index + 4;
|
||||
}
|
||||
|
||||
// Return buffer
|
||||
return _buffer;
|
||||
};
|
||||
|
||||
var Response = function(bson, message, msgHeader, msgBody, opts) {
|
||||
opts = opts || { promoteLongs: true, promoteValues: true, promoteBuffers: false };
|
||||
this.parsed = false;
|
||||
this.raw = message;
|
||||
this.data = msgBody;
|
||||
this.bson = bson;
|
||||
this.opts = opts;
|
||||
|
||||
// Read the message header
|
||||
this.length = msgHeader.length;
|
||||
this.requestId = msgHeader.requestId;
|
||||
this.responseTo = msgHeader.responseTo;
|
||||
this.opCode = msgHeader.opCode;
|
||||
this.fromCompressed = msgHeader.fromCompressed;
|
||||
|
||||
// Read the message body
|
||||
this.responseFlags = msgBody.readInt32LE(0);
|
||||
this.cursorId = new Long(msgBody.readInt32LE(4), msgBody.readInt32LE(8));
|
||||
this.startingFrom = msgBody.readInt32LE(12);
|
||||
this.numberReturned = msgBody.readInt32LE(16);
|
||||
|
||||
// Preallocate document array
|
||||
this.documents = new Array(this.numberReturned);
|
||||
|
||||
// Flag values
|
||||
this.cursorNotFound = (this.responseFlags & CURSOR_NOT_FOUND) !== 0;
|
||||
this.queryFailure = (this.responseFlags & QUERY_FAILURE) !== 0;
|
||||
this.shardConfigStale = (this.responseFlags & SHARD_CONFIG_STALE) !== 0;
|
||||
this.awaitCapable = (this.responseFlags & AWAIT_CAPABLE) !== 0;
|
||||
this.promoteLongs = typeof opts.promoteLongs === 'boolean' ? opts.promoteLongs : true;
|
||||
this.promoteValues = typeof opts.promoteValues === 'boolean' ? opts.promoteValues : true;
|
||||
this.promoteBuffers = typeof opts.promoteBuffers === 'boolean' ? opts.promoteBuffers : false;
|
||||
};
|
||||
|
||||
Response.prototype.isParsed = function() {
|
||||
return this.parsed;
|
||||
};
|
||||
|
||||
Response.prototype.parse = function(options) {
|
||||
// Don't parse again if not needed
|
||||
if (this.parsed) return;
|
||||
options = options || {};
|
||||
|
||||
// Allow the return of raw documents instead of parsing
|
||||
var raw = options.raw || false;
|
||||
var documentsReturnedIn = options.documentsReturnedIn || null;
|
||||
var promoteLongs =
|
||||
typeof options.promoteLongs === 'boolean' ? options.promoteLongs : this.opts.promoteLongs;
|
||||
var promoteValues =
|
||||
typeof options.promoteValues === 'boolean' ? options.promoteValues : this.opts.promoteValues;
|
||||
var promoteBuffers =
|
||||
typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : this.opts.promoteBuffers;
|
||||
var bsonSize, _options;
|
||||
|
||||
// Set up the options
|
||||
_options = {
|
||||
promoteLongs: promoteLongs,
|
||||
promoteValues: promoteValues,
|
||||
promoteBuffers: promoteBuffers
|
||||
};
|
||||
|
||||
// Position within OP_REPLY at which documents start
|
||||
// (See https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#wire-op-reply)
|
||||
this.index = 20;
|
||||
|
||||
//
|
||||
// Single document and documentsReturnedIn set
|
||||
//
|
||||
if (this.numberReturned === 1 && documentsReturnedIn != null && raw) {
|
||||
// Calculate the bson size
|
||||
bsonSize =
|
||||
this.data[this.index] |
|
||||
(this.data[this.index + 1] << 8) |
|
||||
(this.data[this.index + 2] << 16) |
|
||||
(this.data[this.index + 3] << 24);
|
||||
// Slice out the buffer containing the command result document
|
||||
var document = this.data.slice(this.index, this.index + bsonSize);
|
||||
// Set up field we wish to keep as raw
|
||||
var fieldsAsRaw = {};
|
||||
fieldsAsRaw[documentsReturnedIn] = true;
|
||||
_options.fieldsAsRaw = fieldsAsRaw;
|
||||
|
||||
// Deserialize but keep the array of documents in non-parsed form
|
||||
var doc = this.bson.deserialize(document, _options);
|
||||
|
||||
if (doc instanceof Error) {
|
||||
throw doc;
|
||||
}
|
||||
|
||||
if (doc.errmsg) {
|
||||
throw new MongoError(doc.errmsg);
|
||||
}
|
||||
|
||||
if (!doc.cursor) {
|
||||
throw new MongoError('Cursor not found');
|
||||
}
|
||||
|
||||
// Get the documents
|
||||
this.documents = doc.cursor[documentsReturnedIn];
|
||||
this.numberReturned = this.documents.length;
|
||||
// Ensure we have a Long valie cursor id
|
||||
this.cursorId =
|
||||
typeof doc.cursor.id === 'number' ? Long.fromNumber(doc.cursor.id) : doc.cursor.id;
|
||||
|
||||
// Adjust the index
|
||||
this.index = this.index + bsonSize;
|
||||
|
||||
// Set as parsed
|
||||
this.parsed = true;
|
||||
return;
|
||||
}
|
||||
|
||||
//
|
||||
// Parse Body
|
||||
//
|
||||
for (var i = 0; i < this.numberReturned; i++) {
|
||||
bsonSize =
|
||||
this.data[this.index] |
|
||||
(this.data[this.index + 1] << 8) |
|
||||
(this.data[this.index + 2] << 16) |
|
||||
(this.data[this.index + 3] << 24);
|
||||
|
||||
// If we have raw results specified slice the return document
|
||||
if (raw) {
|
||||
this.documents[i] = this.data.slice(this.index, this.index + bsonSize);
|
||||
} else {
|
||||
this.documents[i] = this.bson.deserialize(
|
||||
this.data.slice(this.index, this.index + bsonSize),
|
||||
_options
|
||||
);
|
||||
}
|
||||
|
||||
// Adjust the index
|
||||
this.index = this.index + bsonSize;
|
||||
}
|
||||
|
||||
// Set parsed
|
||||
this.parsed = true;
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
Query: Query,
|
||||
GetMore: GetMore,
|
||||
Response: Response,
|
||||
KillCursor: KillCursor
|
||||
};
|
||||
+805
@@ -0,0 +1,805 @@
|
||||
'use strict';
|
||||
|
||||
var inherits = require('util').inherits,
|
||||
EventEmitter = require('events').EventEmitter,
|
||||
net = require('net'),
|
||||
tls = require('tls'),
|
||||
crypto = require('crypto'),
|
||||
f = require('util').format,
|
||||
debugOptions = require('./utils').debugOptions,
|
||||
parseHeader = require('../wireprotocol/shared').parseHeader,
|
||||
decompress = require('../wireprotocol/compression').decompress,
|
||||
Response = require('./commands').Response,
|
||||
MongoNetworkError = require('../error').MongoNetworkError,
|
||||
Logger = require('./logger'),
|
||||
OP_COMPRESSED = require('../wireprotocol/shared').opcodes.OP_COMPRESSED,
|
||||
MESSAGE_HEADER_SIZE = require('../wireprotocol/shared').MESSAGE_HEADER_SIZE,
|
||||
Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
var _id = 0;
|
||||
var debugFields = [
|
||||
'host',
|
||||
'port',
|
||||
'size',
|
||||
'keepAlive',
|
||||
'keepAliveInitialDelay',
|
||||
'noDelay',
|
||||
'connectionTimeout',
|
||||
'socketTimeout',
|
||||
'singleBufferSerializtion',
|
||||
'ssl',
|
||||
'ca',
|
||||
'crl',
|
||||
'cert',
|
||||
'rejectUnauthorized',
|
||||
'promoteLongs',
|
||||
'promoteValues',
|
||||
'promoteBuffers',
|
||||
'checkServerIdentity'
|
||||
];
|
||||
|
||||
var connectionAccountingSpy = undefined;
|
||||
var connectionAccounting = false;
|
||||
var connections = {};
|
||||
|
||||
/**
|
||||
* Creates a new Connection instance
|
||||
* @class
|
||||
* @param {string} options.host The server host
|
||||
* @param {number} options.port The server port
|
||||
* @param {number} [options.family=null] IP version for DNS lookup, passed down to Node's [`dns.lookup()` function](https://nodejs.org/api/dns.html#dns_dns_lookup_hostname_options_callback). If set to `6`, will only look for ipv6 addresses.
|
||||
* @param {boolean} [options.keepAlive=true] TCP Connection keep alive enabled
|
||||
* @param {number} [options.keepAliveInitialDelay=300000] Initial delay before TCP keep alive enabled
|
||||
* @param {boolean} [options.noDelay=true] TCP Connection no delay
|
||||
* @param {number} [options.connectionTimeout=30000] TCP Connection timeout setting
|
||||
* @param {number} [options.socketTimeout=360000] TCP Socket timeout setting
|
||||
* @param {boolean} [options.singleBufferSerializtion=true] Serialize into single buffer, trade of peak memory for serialization speed
|
||||
* @param {boolean} [options.ssl=false] Use SSL for connection
|
||||
* @param {boolean|function} [options.checkServerIdentity=true] Ensure we check server identify during SSL, set to false to disable checking. Only works for Node 0.12.x or higher. You can pass in a boolean or your own checkServerIdentity override function.
|
||||
* @param {Buffer} [options.ca] SSL Certificate store binary buffer
|
||||
* @param {Buffer} [options.crl] SSL Certificate revocation store binary buffer
|
||||
* @param {Buffer} [options.cert] SSL Certificate binary buffer
|
||||
* @param {Buffer} [options.key] SSL Key file binary buffer
|
||||
* @param {string} [options.passphrase] SSL Certificate pass phrase
|
||||
* @param {boolean} [options.rejectUnauthorized=true] Reject unauthorized server certificates
|
||||
* @param {boolean} [options.promoteLongs=true] Convert Long values from the db into Numbers if they fit into 53 bits
|
||||
* @param {boolean} [options.promoteValues=true] Promotes BSON values to native types where possible, set to false to only receive wrapper types.
|
||||
* @param {boolean} [options.promoteBuffers=false] Promotes Binary BSON values to native Node Buffers.
|
||||
* @fires Connection#connect
|
||||
* @fires Connection#close
|
||||
* @fires Connection#error
|
||||
* @fires Connection#timeout
|
||||
* @fires Connection#parseError
|
||||
* @return {Connection} A cursor instance
|
||||
*/
|
||||
var Connection = function(messageHandler, options) {
|
||||
// Add event listener
|
||||
EventEmitter.call(this);
|
||||
// Set empty if no options passed
|
||||
this.options = options || {};
|
||||
// Identification information
|
||||
this.id = _id++;
|
||||
// Logger instance
|
||||
this.logger = Logger('Connection', options);
|
||||
// No bson parser passed in
|
||||
if (!options.bson) throw new Error('must pass in valid bson parser');
|
||||
// Get bson parser
|
||||
this.bson = options.bson;
|
||||
// Grouping tag used for debugging purposes
|
||||
this.tag = options.tag;
|
||||
// Message handler
|
||||
this.messageHandler = messageHandler;
|
||||
|
||||
// Max BSON message size
|
||||
this.maxBsonMessageSize = options.maxBsonMessageSize || 1024 * 1024 * 16 * 4;
|
||||
// Debug information
|
||||
if (this.logger.isDebug())
|
||||
this.logger.debug(
|
||||
f(
|
||||
'creating connection %s with options [%s]',
|
||||
this.id,
|
||||
JSON.stringify(debugOptions(debugFields, options))
|
||||
)
|
||||
);
|
||||
|
||||
// Default options
|
||||
this.port = options.port || 27017;
|
||||
this.host = options.host || 'localhost';
|
||||
this.family = typeof options.family === 'number' ? options.family : void 0;
|
||||
this.keepAlive = typeof options.keepAlive === 'boolean' ? options.keepAlive : true;
|
||||
this.keepAliveInitialDelay =
|
||||
typeof options.keepAliveInitialDelay === 'number' ? options.keepAliveInitialDelay : 300000;
|
||||
this.noDelay = typeof options.noDelay === 'boolean' ? options.noDelay : true;
|
||||
this.connectionTimeout =
|
||||
typeof options.connectionTimeout === 'number' ? options.connectionTimeout : 30000;
|
||||
this.socketTimeout = typeof options.socketTimeout === 'number' ? options.socketTimeout : 360000;
|
||||
|
||||
// Is the keepAliveInitialDelay > socketTimeout set it to half of socketTimeout
|
||||
if (this.keepAliveInitialDelay > this.socketTimeout) {
|
||||
this.keepAliveInitialDelay = Math.round(this.socketTimeout / 2);
|
||||
}
|
||||
|
||||
// If connection was destroyed
|
||||
this.destroyed = false;
|
||||
|
||||
// Check if we have a domain socket
|
||||
this.domainSocket = this.host.indexOf('/') !== -1;
|
||||
|
||||
// Serialize commands using function
|
||||
this.singleBufferSerializtion =
|
||||
typeof options.singleBufferSerializtion === 'boolean' ? options.singleBufferSerializtion : true;
|
||||
this.serializationFunction = this.singleBufferSerializtion ? 'toBinUnified' : 'toBin';
|
||||
|
||||
// SSL options
|
||||
this.ca = options.ca || null;
|
||||
this.crl = options.crl || null;
|
||||
this.cert = options.cert || null;
|
||||
this.key = options.key || null;
|
||||
this.passphrase = options.passphrase || null;
|
||||
this.ciphers = options.ciphers || null;
|
||||
this.ecdhCurve = options.ecdhCurve || null;
|
||||
this.ssl = typeof options.ssl === 'boolean' ? options.ssl : false;
|
||||
this.rejectUnauthorized =
|
||||
typeof options.rejectUnauthorized === 'boolean' ? options.rejectUnauthorized : true;
|
||||
this.checkServerIdentity =
|
||||
typeof options.checkServerIdentity === 'boolean' ||
|
||||
typeof options.checkServerIdentity === 'function'
|
||||
? options.checkServerIdentity
|
||||
: true;
|
||||
|
||||
// If ssl not enabled
|
||||
if (!this.ssl) this.rejectUnauthorized = false;
|
||||
|
||||
// Response options
|
||||
this.responseOptions = {
|
||||
promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
|
||||
promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
|
||||
promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false
|
||||
};
|
||||
|
||||
// Flushing
|
||||
this.flushing = false;
|
||||
this.queue = [];
|
||||
|
||||
// Internal state
|
||||
this.connection = null;
|
||||
this.writeStream = null;
|
||||
|
||||
// Create hash method
|
||||
var hash = crypto.createHash('sha1');
|
||||
hash.update(f('%s:%s', this.host, this.port));
|
||||
|
||||
// Create a hash name
|
||||
this.hashedName = hash.digest('hex');
|
||||
|
||||
// All operations in flight on the connection
|
||||
this.workItems = [];
|
||||
};
|
||||
|
||||
inherits(Connection, EventEmitter);
|
||||
|
||||
Connection.prototype.setSocketTimeout = function(value) {
|
||||
if (this.connection) {
|
||||
this.connection.setTimeout(value);
|
||||
}
|
||||
};
|
||||
|
||||
Connection.prototype.resetSocketTimeout = function() {
|
||||
if (this.connection) {
|
||||
this.connection.setTimeout(this.socketTimeout);
|
||||
}
|
||||
};
|
||||
|
||||
Connection.enableConnectionAccounting = function(spy) {
|
||||
if (spy) {
|
||||
connectionAccountingSpy = spy;
|
||||
}
|
||||
|
||||
connectionAccounting = true;
|
||||
connections = {};
|
||||
};
|
||||
|
||||
Connection.disableConnectionAccounting = function() {
|
||||
connectionAccounting = false;
|
||||
connectionAccountingSpy = undefined;
|
||||
};
|
||||
|
||||
Connection.connections = function() {
|
||||
return connections;
|
||||
};
|
||||
|
||||
function deleteConnection(id) {
|
||||
// console.log("=== deleted connection " + id + " :: " + (connections[id] ? connections[id].port : ''))
|
||||
delete connections[id];
|
||||
|
||||
if (connectionAccountingSpy) {
|
||||
connectionAccountingSpy.deleteConnection(id);
|
||||
}
|
||||
}
|
||||
|
||||
function addConnection(id, connection) {
|
||||
// console.log("=== added connection " + id + " :: " + connection.port)
|
||||
connections[id] = connection;
|
||||
|
||||
if (connectionAccountingSpy) {
|
||||
connectionAccountingSpy.addConnection(id, connection);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Connection handlers
|
||||
var errorHandler = function(self) {
|
||||
return function(err) {
|
||||
if (connectionAccounting) deleteConnection(self.id);
|
||||
// Debug information
|
||||
if (self.logger.isDebug())
|
||||
self.logger.debug(
|
||||
f(
|
||||
'connection %s for [%s:%s] errored out with [%s]',
|
||||
self.id,
|
||||
self.host,
|
||||
self.port,
|
||||
JSON.stringify(err)
|
||||
)
|
||||
);
|
||||
// Emit the error
|
||||
if (self.listeners('error').length > 0) self.emit('error', new MongoNetworkError(err), self);
|
||||
};
|
||||
};
|
||||
|
||||
var timeoutHandler = function(self) {
|
||||
return function() {
|
||||
if (connectionAccounting) deleteConnection(self.id);
|
||||
// Debug information
|
||||
if (self.logger.isDebug())
|
||||
self.logger.debug(f('connection %s for [%s:%s] timed out', self.id, self.host, self.port));
|
||||
// Emit timeout error
|
||||
self.emit(
|
||||
'timeout',
|
||||
new MongoNetworkError(f('connection %s to %s:%s timed out', self.id, self.host, self.port)),
|
||||
self
|
||||
);
|
||||
};
|
||||
};
|
||||
|
||||
var closeHandler = function(self) {
|
||||
return function(hadError) {
|
||||
if (connectionAccounting) deleteConnection(self.id);
|
||||
// Debug information
|
||||
if (self.logger.isDebug())
|
||||
self.logger.debug(f('connection %s with for [%s:%s] closed', self.id, self.host, self.port));
|
||||
|
||||
// Emit close event
|
||||
if (!hadError) {
|
||||
self.emit(
|
||||
'close',
|
||||
new MongoNetworkError(f('connection %s to %s:%s closed', self.id, self.host, self.port)),
|
||||
self
|
||||
);
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
// Handle a message once it is recieved
|
||||
var emitMessageHandler = function(self, message) {
|
||||
var msgHeader = parseHeader(message);
|
||||
if (msgHeader.opCode === OP_COMPRESSED) {
|
||||
msgHeader.fromCompressed = true;
|
||||
var index = MESSAGE_HEADER_SIZE;
|
||||
msgHeader.opCode = message.readInt32LE(index);
|
||||
index += 4;
|
||||
msgHeader.length = message.readInt32LE(index);
|
||||
index += 4;
|
||||
var compressorID = message[index];
|
||||
index++;
|
||||
decompress(compressorID, message.slice(index), function(err, decompressedMsgBody) {
|
||||
if (err) {
|
||||
throw err;
|
||||
}
|
||||
if (decompressedMsgBody.length !== msgHeader.length) {
|
||||
throw new Error(
|
||||
'Decompressing a compressed message from the server failed. The message is corrupt.'
|
||||
);
|
||||
}
|
||||
self.messageHandler(
|
||||
new Response(self.bson, message, msgHeader, decompressedMsgBody, self.responseOptions),
|
||||
self
|
||||
);
|
||||
});
|
||||
} else {
|
||||
self.messageHandler(
|
||||
new Response(
|
||||
self.bson,
|
||||
message,
|
||||
msgHeader,
|
||||
message.slice(MESSAGE_HEADER_SIZE),
|
||||
self.responseOptions
|
||||
),
|
||||
self
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
var dataHandler = function(self) {
|
||||
return function(data) {
|
||||
// Parse until we are done with the data
|
||||
while (data.length > 0) {
|
||||
// If we still have bytes to read on the current message
|
||||
if (self.bytesRead > 0 && self.sizeOfMessage > 0) {
|
||||
// Calculate the amount of remaining bytes
|
||||
var remainingBytesToRead = self.sizeOfMessage - self.bytesRead;
|
||||
// Check if the current chunk contains the rest of the message
|
||||
if (remainingBytesToRead > data.length) {
|
||||
// Copy the new data into the exiting buffer (should have been allocated when we know the message size)
|
||||
data.copy(self.buffer, self.bytesRead);
|
||||
// Adjust the number of bytes read so it point to the correct index in the buffer
|
||||
self.bytesRead = self.bytesRead + data.length;
|
||||
|
||||
// Reset state of buffer
|
||||
data = Buffer.alloc(0);
|
||||
} else {
|
||||
// Copy the missing part of the data into our current buffer
|
||||
data.copy(self.buffer, self.bytesRead, 0, remainingBytesToRead);
|
||||
// Slice the overflow into a new buffer that we will then re-parse
|
||||
data = data.slice(remainingBytesToRead);
|
||||
|
||||
// Emit current complete message
|
||||
try {
|
||||
var emitBuffer = self.buffer;
|
||||
// Reset state of buffer
|
||||
self.buffer = null;
|
||||
self.sizeOfMessage = 0;
|
||||
self.bytesRead = 0;
|
||||
self.stubBuffer = null;
|
||||
|
||||
emitMessageHandler(self, emitBuffer);
|
||||
} catch (err) {
|
||||
var errorObject = {
|
||||
err: 'socketHandler',
|
||||
trace: err,
|
||||
bin: self.buffer,
|
||||
parseState: {
|
||||
sizeOfMessage: self.sizeOfMessage,
|
||||
bytesRead: self.bytesRead,
|
||||
stubBuffer: self.stubBuffer
|
||||
}
|
||||
};
|
||||
// We got a parse Error fire it off then keep going
|
||||
self.emit('parseError', errorObject, self);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// Stub buffer is kept in case we don't get enough bytes to determine the
|
||||
// size of the message (< 4 bytes)
|
||||
if (self.stubBuffer != null && self.stubBuffer.length > 0) {
|
||||
// If we have enough bytes to determine the message size let's do it
|
||||
if (self.stubBuffer.length + data.length > 4) {
|
||||
// Prepad the data
|
||||
var newData = Buffer.alloc(self.stubBuffer.length + data.length);
|
||||
self.stubBuffer.copy(newData, 0);
|
||||
data.copy(newData, self.stubBuffer.length);
|
||||
// Reassign for parsing
|
||||
data = newData;
|
||||
|
||||
// Reset state of buffer
|
||||
self.buffer = null;
|
||||
self.sizeOfMessage = 0;
|
||||
self.bytesRead = 0;
|
||||
self.stubBuffer = null;
|
||||
} else {
|
||||
// Add the the bytes to the stub buffer
|
||||
var newStubBuffer = Buffer.alloc(self.stubBuffer.length + data.length);
|
||||
// Copy existing stub buffer
|
||||
self.stubBuffer.copy(newStubBuffer, 0);
|
||||
// Copy missing part of the data
|
||||
data.copy(newStubBuffer, self.stubBuffer.length);
|
||||
// Exit parsing loop
|
||||
data = Buffer.alloc(0);
|
||||
}
|
||||
} else {
|
||||
if (data.length > 4) {
|
||||
// Retrieve the message size
|
||||
// var sizeOfMessage = data.readUInt32LE(0);
|
||||
var sizeOfMessage = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24);
|
||||
// If we have a negative sizeOfMessage emit error and return
|
||||
if (sizeOfMessage < 0 || sizeOfMessage > self.maxBsonMessageSize) {
|
||||
errorObject = {
|
||||
err: 'socketHandler',
|
||||
trace: '',
|
||||
bin: self.buffer,
|
||||
parseState: {
|
||||
sizeOfMessage: sizeOfMessage,
|
||||
bytesRead: self.bytesRead,
|
||||
stubBuffer: self.stubBuffer
|
||||
}
|
||||
};
|
||||
// We got a parse Error fire it off then keep going
|
||||
self.emit('parseError', errorObject, self);
|
||||
return;
|
||||
}
|
||||
|
||||
// Ensure that the size of message is larger than 0 and less than the max allowed
|
||||
if (
|
||||
sizeOfMessage > 4 &&
|
||||
sizeOfMessage < self.maxBsonMessageSize &&
|
||||
sizeOfMessage > data.length
|
||||
) {
|
||||
self.buffer = Buffer.alloc(sizeOfMessage);
|
||||
// Copy all the data into the buffer
|
||||
data.copy(self.buffer, 0);
|
||||
// Update bytes read
|
||||
self.bytesRead = data.length;
|
||||
// Update sizeOfMessage
|
||||
self.sizeOfMessage = sizeOfMessage;
|
||||
// Ensure stub buffer is null
|
||||
self.stubBuffer = null;
|
||||
// Exit parsing loop
|
||||
data = Buffer.alloc(0);
|
||||
} else if (
|
||||
sizeOfMessage > 4 &&
|
||||
sizeOfMessage < self.maxBsonMessageSize &&
|
||||
sizeOfMessage === data.length
|
||||
) {
|
||||
try {
|
||||
emitBuffer = data;
|
||||
// Reset state of buffer
|
||||
self.buffer = null;
|
||||
self.sizeOfMessage = 0;
|
||||
self.bytesRead = 0;
|
||||
self.stubBuffer = null;
|
||||
// Exit parsing loop
|
||||
data = Buffer.alloc(0);
|
||||
// Emit the message
|
||||
emitMessageHandler(self, emitBuffer);
|
||||
} catch (err) {
|
||||
self.emit('parseError', err, self);
|
||||
}
|
||||
} else if (sizeOfMessage <= 4 || sizeOfMessage > self.maxBsonMessageSize) {
|
||||
errorObject = {
|
||||
err: 'socketHandler',
|
||||
trace: null,
|
||||
bin: data,
|
||||
parseState: {
|
||||
sizeOfMessage: sizeOfMessage,
|
||||
bytesRead: 0,
|
||||
buffer: null,
|
||||
stubBuffer: null
|
||||
}
|
||||
};
|
||||
// We got a parse Error fire it off then keep going
|
||||
self.emit('parseError', errorObject, self);
|
||||
|
||||
// Clear out the state of the parser
|
||||
self.buffer = null;
|
||||
self.sizeOfMessage = 0;
|
||||
self.bytesRead = 0;
|
||||
self.stubBuffer = null;
|
||||
// Exit parsing loop
|
||||
data = Buffer.alloc(0);
|
||||
} else {
|
||||
emitBuffer = data.slice(0, sizeOfMessage);
|
||||
// Reset state of buffer
|
||||
self.buffer = null;
|
||||
self.sizeOfMessage = 0;
|
||||
self.bytesRead = 0;
|
||||
self.stubBuffer = null;
|
||||
// Copy rest of message
|
||||
data = data.slice(sizeOfMessage);
|
||||
// Emit the message
|
||||
emitMessageHandler(self, emitBuffer);
|
||||
}
|
||||
} else {
|
||||
// Create a buffer that contains the space for the non-complete message
|
||||
self.stubBuffer = Buffer.alloc(data.length);
|
||||
// Copy the data to the stub buffer
|
||||
data.copy(self.stubBuffer, 0);
|
||||
// Exit parsing loop
|
||||
data = Buffer.alloc(0);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
// List of socket level valid ssl options
|
||||
var legalSslSocketOptions = [
|
||||
'pfx',
|
||||
'key',
|
||||
'passphrase',
|
||||
'cert',
|
||||
'ca',
|
||||
'ciphers',
|
||||
'NPNProtocols',
|
||||
'ALPNProtocols',
|
||||
'servername',
|
||||
'ecdhCurve',
|
||||
'secureProtocol',
|
||||
'secureContext',
|
||||
'session',
|
||||
'minDHSize'
|
||||
];
|
||||
|
||||
function merge(options1, options2) {
|
||||
// Merge in any allowed ssl options
|
||||
for (var name in options2) {
|
||||
if (options2[name] != null && legalSslSocketOptions.indexOf(name) !== -1) {
|
||||
options1[name] = options2[name];
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function makeSSLConnection(self, _options) {
|
||||
let sslOptions = {
|
||||
socket: self.connection,
|
||||
rejectUnauthorized: self.rejectUnauthorized
|
||||
};
|
||||
|
||||
// Merge in options
|
||||
merge(sslOptions, self.options);
|
||||
merge(sslOptions, _options);
|
||||
|
||||
// Set options for ssl
|
||||
if (self.ca) sslOptions.ca = self.ca;
|
||||
if (self.crl) sslOptions.crl = self.crl;
|
||||
if (self.cert) sslOptions.cert = self.cert;
|
||||
if (self.key) sslOptions.key = self.key;
|
||||
if (self.passphrase) sslOptions.passphrase = self.passphrase;
|
||||
|
||||
// Override checkServerIdentity behavior
|
||||
if (self.checkServerIdentity === false) {
|
||||
// Skip the identiy check by retuning undefined as per node documents
|
||||
// https://nodejs.org/api/tls.html#tls_tls_connect_options_callback
|
||||
sslOptions.checkServerIdentity = function() {
|
||||
return undefined;
|
||||
};
|
||||
} else if (typeof self.checkServerIdentity === 'function') {
|
||||
sslOptions.checkServerIdentity = self.checkServerIdentity;
|
||||
}
|
||||
|
||||
// Set default sni servername to be the same as host
|
||||
if (sslOptions.servername == null) {
|
||||
sslOptions.servername = self.host;
|
||||
}
|
||||
|
||||
// Attempt SSL connection
|
||||
const connection = tls.connect(self.port, self.host, sslOptions, function() {
|
||||
// Error on auth or skip
|
||||
if (connection.authorizationError && self.rejectUnauthorized) {
|
||||
return self.emit('error', connection.authorizationError, self, { ssl: true });
|
||||
}
|
||||
|
||||
// Set socket timeout instead of connection timeout
|
||||
connection.setTimeout(self.socketTimeout);
|
||||
// We are done emit connect
|
||||
self.emit('connect', self);
|
||||
});
|
||||
|
||||
// Set the options for the connection
|
||||
connection.setKeepAlive(self.keepAlive, self.keepAliveInitialDelay);
|
||||
connection.setTimeout(self.connectionTimeout);
|
||||
connection.setNoDelay(self.noDelay);
|
||||
|
||||
return connection;
|
||||
}
|
||||
|
||||
function makeUnsecureConnection(self, family) {
|
||||
// Create new connection instance
|
||||
let connection_options;
|
||||
if (self.domainSocket) {
|
||||
connection_options = { path: self.host };
|
||||
} else {
|
||||
connection_options = { port: self.port, host: self.host };
|
||||
connection_options.family = family;
|
||||
}
|
||||
|
||||
const connection = net.createConnection(connection_options);
|
||||
|
||||
// Set the options for the connection
|
||||
connection.setKeepAlive(self.keepAlive, self.keepAliveInitialDelay);
|
||||
connection.setTimeout(self.connectionTimeout);
|
||||
connection.setNoDelay(self.noDelay);
|
||||
|
||||
connection.once('connect', function() {
|
||||
// Set socket timeout instead of connection timeout
|
||||
connection.setTimeout(self.socketTimeout);
|
||||
// Emit connect event
|
||||
self.emit('connect', self);
|
||||
});
|
||||
|
||||
return connection;
|
||||
}
|
||||
|
||||
function doConnect(self, family, _options, _errorHandler) {
|
||||
self.connection = self.ssl
|
||||
? makeSSLConnection(self, _options)
|
||||
: makeUnsecureConnection(self, family);
|
||||
|
||||
// Add handlers for events
|
||||
self.connection.once('error', _errorHandler);
|
||||
self.connection.once('timeout', timeoutHandler(self));
|
||||
self.connection.once('close', closeHandler(self));
|
||||
self.connection.on('data', dataHandler(self));
|
||||
}
|
||||
|
||||
/**
|
||||
* Connect
|
||||
* @method
|
||||
*/
|
||||
Connection.prototype.connect = function(_options) {
|
||||
_options = _options || {};
|
||||
// Set the connections
|
||||
if (connectionAccounting) addConnection(this.id, this);
|
||||
// Check if we are overriding the promoteLongs
|
||||
if (typeof _options.promoteLongs === 'boolean') {
|
||||
this.responseOptions.promoteLongs = _options.promoteLongs;
|
||||
this.responseOptions.promoteValues = _options.promoteValues;
|
||||
this.responseOptions.promoteBuffers = _options.promoteBuffers;
|
||||
}
|
||||
|
||||
const _errorHandler = errorHandler(this);
|
||||
|
||||
if (this.family !== void 0) {
|
||||
return doConnect(this, this.family, _options, _errorHandler);
|
||||
}
|
||||
|
||||
return doConnect(this, 6, _options, err => {
|
||||
if (this.logger.isDebug()) {
|
||||
this.logger.debug(
|
||||
f(
|
||||
'connection %s for [%s:%s] errored out with [%s]',
|
||||
this.id,
|
||||
this.host,
|
||||
this.port,
|
||||
JSON.stringify(err)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// clean up existing event handlers
|
||||
this.connection.removeAllListeners('error');
|
||||
this.connection.removeAllListeners('timeout');
|
||||
this.connection.removeAllListeners('close');
|
||||
this.connection.removeAllListeners('data');
|
||||
this.connection = undefined;
|
||||
|
||||
return doConnect(this, 4, _options, _errorHandler);
|
||||
});
|
||||
};
|
||||
|
||||
/**
|
||||
* Unref this connection
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
Connection.prototype.unref = function() {
|
||||
if (this.connection) this.connection.unref();
|
||||
else {
|
||||
var self = this;
|
||||
this.once('connect', function() {
|
||||
self.connection.unref();
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Destroy connection
|
||||
* @method
|
||||
*/
|
||||
Connection.prototype.destroy = function() {
|
||||
// Set the connections
|
||||
if (connectionAccounting) deleteConnection(this.id);
|
||||
if (this.connection) {
|
||||
// Catch posssible exception thrown by node 0.10.x
|
||||
try {
|
||||
this.connection.end();
|
||||
} catch (err) {} // eslint-disable-line
|
||||
// Destroy connection
|
||||
this.connection.destroy();
|
||||
}
|
||||
|
||||
this.destroyed = true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Write to connection
|
||||
* @method
|
||||
* @param {Command} command Command to write out need to implement toBin and toBinUnified
|
||||
*/
|
||||
Connection.prototype.write = function(buffer) {
|
||||
var i;
|
||||
// Debug Log
|
||||
if (this.logger.isDebug()) {
|
||||
if (!Array.isArray(buffer)) {
|
||||
this.logger.debug(
|
||||
f('writing buffer [%s] to %s:%s', buffer.toString('hex'), this.host, this.port)
|
||||
);
|
||||
} else {
|
||||
for (i = 0; i < buffer.length; i++)
|
||||
this.logger.debug(
|
||||
f('writing buffer [%s] to %s:%s', buffer[i].toString('hex'), this.host, this.port)
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Double check that the connection is not destroyed
|
||||
if (this.connection.destroyed === false) {
|
||||
// Write out the command
|
||||
if (!Array.isArray(buffer)) {
|
||||
this.connection.write(buffer, 'binary');
|
||||
return true;
|
||||
}
|
||||
|
||||
// Iterate over all buffers and write them in order to the socket
|
||||
for (i = 0; i < buffer.length; i++) this.connection.write(buffer[i], 'binary');
|
||||
return true;
|
||||
}
|
||||
|
||||
// Connection is destroyed return write failed
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return id of connection as a string
|
||||
* @method
|
||||
* @return {string}
|
||||
*/
|
||||
Connection.prototype.toString = function() {
|
||||
return '' + this.id;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return json object of connection
|
||||
* @method
|
||||
* @return {object}
|
||||
*/
|
||||
Connection.prototype.toJSON = function() {
|
||||
return { id: this.id, host: this.host, port: this.port };
|
||||
};
|
||||
|
||||
/**
|
||||
* Is the connection connected
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
Connection.prototype.isConnected = function() {
|
||||
if (this.destroyed) return false;
|
||||
return !this.connection.destroyed && this.connection.writable;
|
||||
};
|
||||
|
||||
/**
|
||||
* A server connect event, used to verify that the connection is up and running
|
||||
*
|
||||
* @event Connection#connect
|
||||
* @type {Connection}
|
||||
*/
|
||||
|
||||
/**
|
||||
* The server connection closed, all pool connections closed
|
||||
*
|
||||
* @event Connection#close
|
||||
* @type {Connection}
|
||||
*/
|
||||
|
||||
/**
|
||||
* The server connection caused an error, all pool connections closed
|
||||
*
|
||||
* @event Connection#error
|
||||
* @type {Connection}
|
||||
*/
|
||||
|
||||
/**
|
||||
* The server connection timed out, all pool connections closed
|
||||
*
|
||||
* @event Connection#timeout
|
||||
* @type {Connection}
|
||||
*/
|
||||
|
||||
/**
|
||||
* The driver experienced an invalid message, all pool connections closed
|
||||
*
|
||||
* @event Connection#parseError
|
||||
* @type {Connection}
|
||||
*/
|
||||
|
||||
module.exports = Connection;
|
||||
+246
@@ -0,0 +1,246 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
MongoError = require('../error').MongoError;
|
||||
|
||||
// Filters for classes
|
||||
var classFilters = {};
|
||||
var filteredClasses = {};
|
||||
var level = null;
|
||||
// Save the process id
|
||||
var pid = process.pid;
|
||||
// current logger
|
||||
var currentLogger = null;
|
||||
|
||||
/**
|
||||
* Creates a new Logger instance
|
||||
* @class
|
||||
* @param {string} className The Class name associated with the logging instance
|
||||
* @param {object} [options=null] Optional settings.
|
||||
* @param {Function} [options.logger=null] Custom logger function;
|
||||
* @param {string} [options.loggerLevel=error] Override default global log level.
|
||||
* @return {Logger} a Logger instance.
|
||||
*/
|
||||
var Logger = function(className, options) {
|
||||
if (!(this instanceof Logger)) return new Logger(className, options);
|
||||
options = options || {};
|
||||
|
||||
// Current reference
|
||||
this.className = className;
|
||||
|
||||
// Current logger
|
||||
if (options.logger) {
|
||||
currentLogger = options.logger;
|
||||
} else if (currentLogger == null) {
|
||||
currentLogger = console.log;
|
||||
}
|
||||
|
||||
// Set level of logging, default is error
|
||||
if (options.loggerLevel) {
|
||||
level = options.loggerLevel || 'error';
|
||||
}
|
||||
|
||||
// Add all class names
|
||||
if (filteredClasses[this.className] == null) classFilters[this.className] = true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Log a message at the debug level
|
||||
* @method
|
||||
* @param {string} message The message to log
|
||||
* @param {object} object additional meta data to log
|
||||
* @return {null}
|
||||
*/
|
||||
Logger.prototype.debug = function(message, object) {
|
||||
if (
|
||||
this.isDebug() &&
|
||||
((Object.keys(filteredClasses).length > 0 && filteredClasses[this.className]) ||
|
||||
(Object.keys(filteredClasses).length === 0 && classFilters[this.className]))
|
||||
) {
|
||||
var dateTime = new Date().getTime();
|
||||
var msg = f('[%s-%s:%s] %s %s', 'DEBUG', this.className, pid, dateTime, message);
|
||||
var state = {
|
||||
type: 'debug',
|
||||
message: message,
|
||||
className: this.className,
|
||||
pid: pid,
|
||||
date: dateTime
|
||||
};
|
||||
if (object) state.meta = object;
|
||||
currentLogger(msg, state);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Log a message at the warn level
|
||||
* @method
|
||||
* @param {string} message The message to log
|
||||
* @param {object} object additional meta data to log
|
||||
* @return {null}
|
||||
*/
|
||||
(Logger.prototype.warn = function(message, object) {
|
||||
if (
|
||||
this.isWarn() &&
|
||||
((Object.keys(filteredClasses).length > 0 && filteredClasses[this.className]) ||
|
||||
(Object.keys(filteredClasses).length === 0 && classFilters[this.className]))
|
||||
) {
|
||||
var dateTime = new Date().getTime();
|
||||
var msg = f('[%s-%s:%s] %s %s', 'WARN', this.className, pid, dateTime, message);
|
||||
var state = {
|
||||
type: 'warn',
|
||||
message: message,
|
||||
className: this.className,
|
||||
pid: pid,
|
||||
date: dateTime
|
||||
};
|
||||
if (object) state.meta = object;
|
||||
currentLogger(msg, state);
|
||||
}
|
||||
}),
|
||||
/**
|
||||
* Log a message at the info level
|
||||
* @method
|
||||
* @param {string} message The message to log
|
||||
* @param {object} object additional meta data to log
|
||||
* @return {null}
|
||||
*/
|
||||
(Logger.prototype.info = function(message, object) {
|
||||
if (
|
||||
this.isInfo() &&
|
||||
((Object.keys(filteredClasses).length > 0 && filteredClasses[this.className]) ||
|
||||
(Object.keys(filteredClasses).length === 0 && classFilters[this.className]))
|
||||
) {
|
||||
var dateTime = new Date().getTime();
|
||||
var msg = f('[%s-%s:%s] %s %s', 'INFO', this.className, pid, dateTime, message);
|
||||
var state = {
|
||||
type: 'info',
|
||||
message: message,
|
||||
className: this.className,
|
||||
pid: pid,
|
||||
date: dateTime
|
||||
};
|
||||
if (object) state.meta = object;
|
||||
currentLogger(msg, state);
|
||||
}
|
||||
}),
|
||||
/**
|
||||
* Log a message at the error level
|
||||
* @method
|
||||
* @param {string} message The message to log
|
||||
* @param {object} object additional meta data to log
|
||||
* @return {null}
|
||||
*/
|
||||
(Logger.prototype.error = function(message, object) {
|
||||
if (
|
||||
this.isError() &&
|
||||
((Object.keys(filteredClasses).length > 0 && filteredClasses[this.className]) ||
|
||||
(Object.keys(filteredClasses).length === 0 && classFilters[this.className]))
|
||||
) {
|
||||
var dateTime = new Date().getTime();
|
||||
var msg = f('[%s-%s:%s] %s %s', 'ERROR', this.className, pid, dateTime, message);
|
||||
var state = {
|
||||
type: 'error',
|
||||
message: message,
|
||||
className: this.className,
|
||||
pid: pid,
|
||||
date: dateTime
|
||||
};
|
||||
if (object) state.meta = object;
|
||||
currentLogger(msg, state);
|
||||
}
|
||||
}),
|
||||
/**
|
||||
* Is the logger set at info level
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
(Logger.prototype.isInfo = function() {
|
||||
return level === 'info' || level === 'debug';
|
||||
}),
|
||||
/**
|
||||
* Is the logger set at error level
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
(Logger.prototype.isError = function() {
|
||||
return level === 'error' || level === 'info' || level === 'debug';
|
||||
}),
|
||||
/**
|
||||
* Is the logger set at error level
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
(Logger.prototype.isWarn = function() {
|
||||
return level === 'error' || level === 'warn' || level === 'info' || level === 'debug';
|
||||
}),
|
||||
/**
|
||||
* Is the logger set at debug level
|
||||
* @method
|
||||
* @return {boolean}
|
||||
*/
|
||||
(Logger.prototype.isDebug = function() {
|
||||
return level === 'debug';
|
||||
});
|
||||
|
||||
/**
|
||||
* Resets the logger to default settings, error and no filtered classes
|
||||
* @method
|
||||
* @return {null}
|
||||
*/
|
||||
Logger.reset = function() {
|
||||
level = 'error';
|
||||
filteredClasses = {};
|
||||
};
|
||||
|
||||
/**
|
||||
* Get the current logger function
|
||||
* @method
|
||||
* @return {function}
|
||||
*/
|
||||
Logger.currentLogger = function() {
|
||||
return currentLogger;
|
||||
};
|
||||
|
||||
/**
|
||||
* Set the current logger function
|
||||
* @method
|
||||
* @param {function} logger Logger function.
|
||||
* @return {null}
|
||||
*/
|
||||
Logger.setCurrentLogger = function(logger) {
|
||||
if (typeof logger !== 'function') throw new MongoError('current logger must be a function');
|
||||
currentLogger = logger;
|
||||
};
|
||||
|
||||
/**
|
||||
* Set what classes to log.
|
||||
* @method
|
||||
* @param {string} type The type of filter (currently only class)
|
||||
* @param {string[]} values The filters to apply
|
||||
* @return {null}
|
||||
*/
|
||||
Logger.filter = function(type, values) {
|
||||
if (type === 'class' && Array.isArray(values)) {
|
||||
filteredClasses = {};
|
||||
|
||||
values.forEach(function(x) {
|
||||
filteredClasses[x] = true;
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Set the current log level
|
||||
* @method
|
||||
* @param {string} level Set current log level (debug, info, error)
|
||||
* @return {null}
|
||||
*/
|
||||
Logger.setLevel = function(_level) {
|
||||
if (_level !== 'info' && _level !== 'error' && _level !== 'debug' && _level !== 'warn') {
|
||||
throw new Error(f('%s is an illegal logging level', _level));
|
||||
}
|
||||
|
||||
level = _level;
|
||||
};
|
||||
|
||||
module.exports = Logger;
|
||||
+1657
File diff suppressed because it is too large.
Load diff
+113
@@ -0,0 +1,113 @@
|
||||
'use strict';
|
||||
|
||||
var f = require('util').format,
|
||||
require_optional = require('require_optional');
|
||||
|
||||
// Set property function
|
||||
var setProperty = function(obj, prop, flag, values) {
|
||||
Object.defineProperty(obj, prop.name, {
|
||||
enumerable: true,
|
||||
set: function(value) {
|
||||
if (typeof value !== 'boolean') throw new Error(f('%s required a boolean', prop.name));
|
||||
// Flip the bit to 1
|
||||
if (value === true) values.flags |= flag;
|
||||
// Flip the bit to 0 if it's set, otherwise ignore
|
||||
if (value === false && (values.flags & flag) === flag) values.flags ^= flag;
|
||||
prop.value = value;
|
||||
},
|
||||
get: function() {
|
||||
return prop.value;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
// Set property function
|
||||
var getProperty = function(obj, propName, fieldName, values, func) {
|
||||
Object.defineProperty(obj, propName, {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
// Not parsed yet, parse it
|
||||
if (values[fieldName] == null && obj.isParsed && !obj.isParsed()) {
|
||||
obj.parse();
|
||||
}
|
||||
|
||||
// Do we have a post processing function
|
||||
if (typeof func === 'function') return func(values[fieldName]);
|
||||
// Return raw value
|
||||
return values[fieldName];
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
// Set simple property
|
||||
var getSingleProperty = function(obj, name, value) {
|
||||
Object.defineProperty(obj, name, {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return value;
|
||||
}
|
||||
});
|
||||
};
|
||||
|
||||
// Shallow copy
|
||||
var copy = function(fObj, tObj) {
|
||||
tObj = tObj || {};
|
||||
for (var name in fObj) tObj[name] = fObj[name];
|
||||
return tObj;
|
||||
};
|
||||
|
||||
var debugOptions = function(debugFields, options) {
|
||||
var finaloptions = {};
|
||||
debugFields.forEach(function(n) {
|
||||
finaloptions[n] = options[n];
|
||||
});
|
||||
|
||||
return finaloptions;
|
||||
};
|
||||
|
||||
var retrieveBSON = function() {
|
||||
var BSON = require('bson');
|
||||
BSON.native = false;
|
||||
|
||||
try {
|
||||
var optionalBSON = require_optional('bson-ext');
|
||||
if (optionalBSON) {
|
||||
optionalBSON.native = true;
|
||||
return optionalBSON;
|
||||
}
|
||||
} catch (err) {} // eslint-disable-line
|
||||
|
||||
return BSON;
|
||||
};
|
||||
|
||||
// Throw an error if an attempt to use Snappy is made when Snappy is not installed
|
||||
var noSnappyWarning = function() {
|
||||
throw new Error(
|
||||
'Attempted to use Snappy compression, but Snappy is not installed. Install or disable Snappy compression and try again.'
|
||||
);
|
||||
};
|
||||
|
||||
// Facilitate loading Snappy optionally
|
||||
var retrieveSnappy = function() {
|
||||
var snappy = null;
|
||||
try {
|
||||
snappy = require_optional('snappy');
|
||||
} catch (error) {} // eslint-disable-line
|
||||
if (!snappy) {
|
||||
snappy = {
|
||||
compress: noSnappyWarning,
|
||||
uncompress: noSnappyWarning,
|
||||
compressSync: noSnappyWarning,
|
||||
uncompressSync: noSnappyWarning
|
||||
};
|
||||
}
|
||||
return snappy;
|
||||
};
|
||||
|
||||
exports.setProperty = setProperty;
|
||||
exports.getProperty = getProperty;
|
||||
exports.getSingleProperty = getSingleProperty;
|
||||
exports.copy = copy;
|
||||
exports.debugOptions = debugOptions;
|
||||
exports.retrieveBSON = retrieveBSON;
|
||||
exports.retrieveSnappy = retrieveSnappy;
|
||||
+836
@@ -0,0 +1,836 @@
|
||||
'use strict';
|
||||
|
||||
const Logger = require('./connection/logger');
|
||||
const retrieveBSON = require('./connection/utils').retrieveBSON;
|
||||
const MongoError = require('./error').MongoError;
|
||||
const MongoNetworkError = require('./error').MongoNetworkError;
|
||||
const mongoErrorContextSymbol = require('./error').mongoErrorContextSymbol;
|
||||
const f = require('util').format;
|
||||
const collationNotSupported = require('./utils').collationNotSupported;
|
||||
|
||||
var BSON = retrieveBSON(),
|
||||
Long = BSON.Long;
|
||||
|
||||
/**
|
||||
* This is a cursor results callback
|
||||
*
|
||||
* @callback resultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {object} document
|
||||
*/
|
||||
|
||||
/**
|
||||
* @fileOverview The **Cursor** class is an internal class that embodies a cursor on MongoDB
|
||||
* allowing for iteration over the results returned from the underlying query.
|
||||
*
|
||||
* **CURSORS Cannot directly be instantiated**
|
||||
* @example
|
||||
* var Server = require('mongodb-core').Server
|
||||
* , ReadPreference = require('mongodb-core').ReadPreference
|
||||
* , assert = require('assert');
|
||||
*
|
||||
* var server = new Server({host: 'localhost', port: 27017});
|
||||
* // Wait for the connection event
|
||||
* server.on('connect', function(server) {
|
||||
* assert.equal(null, err);
|
||||
*
|
||||
* // Execute the write
|
||||
* var cursor = _server.cursor('integration_tests.inserts_example4', {
|
||||
* find: 'integration_tests.example4'
|
||||
* , query: {a:1}
|
||||
* }, {
|
||||
* readPreference: new ReadPreference('secondary');
|
||||
* });
|
||||
*
|
||||
* // Get the first document
|
||||
* cursor.next(function(err, doc) {
|
||||
* assert.equal(null, err);
|
||||
* server.destroy();
|
||||
* });
|
||||
* });
|
||||
*
|
||||
* // Start connecting
|
||||
* server.connect();
|
||||
*/
|
||||
|
||||
/**
|
||||
* Creates a new Cursor, not to be used directly
|
||||
* @class
|
||||
* @param {object} bson An instance of the BSON parser
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {{object}|Long} cmd The selector (can be a command or a cursorId)
|
||||
* @param {object} [options=null] Optional settings.
|
||||
* @param {object} [options.batchSize=1000] Batchsize for the operation
|
||||
* @param {array} [options.documents=[]] Initial documents list for cursor
|
||||
* @param {object} [options.transforms=null] Transform methods for the cursor results
|
||||
* @param {function} [options.transforms.query] Transform the value returned from the initial query
|
||||
* @param {function} [options.transforms.doc] Transform each document returned from Cursor.prototype.next
|
||||
* @param {object} topology The server topology instance.
|
||||
* @param {object} topologyOptions The server topology options.
|
||||
* @return {Cursor} A cursor instance
|
||||
* @property {number} cursorBatchSize The current cursorBatchSize for the cursor
|
||||
* @property {number} cursorLimit The current cursorLimit for the cursor
|
||||
* @property {number} cursorSkip The current cursorSkip for the cursor
|
||||
*/
|
||||
var Cursor = function(bson, ns, cmd, options, topology, topologyOptions) {
|
||||
options = options || {};
|
||||
|
||||
// Cursor pool
|
||||
this.pool = null;
|
||||
// Cursor server
|
||||
this.server = null;
|
||||
|
||||
// Do we have a not connected handler
|
||||
this.disconnectHandler = options.disconnectHandler;
|
||||
|
||||
// Set local values
|
||||
this.bson = bson;
|
||||
this.ns = ns;
|
||||
this.cmd = cmd;
|
||||
this.options = options;
|
||||
this.topology = topology;
|
||||
|
||||
// All internal state
|
||||
this.cursorState = {
|
||||
cursorId: null,
|
||||
cmd: cmd,
|
||||
documents: options.documents || [],
|
||||
cursorIndex: 0,
|
||||
dead: false,
|
||||
killed: false,
|
||||
init: false,
|
||||
notified: false,
|
||||
limit: options.limit || cmd.limit || 0,
|
||||
skip: options.skip || cmd.skip || 0,
|
||||
batchSize: options.batchSize || cmd.batchSize || 1000,
|
||||
currentLimit: 0,
|
||||
// Result field name if not a cursor (contains the array of results)
|
||||
transforms: options.transforms
|
||||
};
|
||||
|
||||
if (typeof options.session === 'object') {
|
||||
this.cursorState.session = options.session;
|
||||
}
|
||||
|
||||
// Add promoteLong to cursor state
|
||||
if (typeof topologyOptions.promoteLongs === 'boolean') {
|
||||
this.cursorState.promoteLongs = topologyOptions.promoteLongs;
|
||||
} else if (typeof options.promoteLongs === 'boolean') {
|
||||
this.cursorState.promoteLongs = options.promoteLongs;
|
||||
}
|
||||
|
||||
// Add promoteValues to cursor state
|
||||
if (typeof topologyOptions.promoteValues === 'boolean') {
|
||||
this.cursorState.promoteValues = topologyOptions.promoteValues;
|
||||
} else if (typeof options.promoteValues === 'boolean') {
|
||||
this.cursorState.promoteValues = options.promoteValues;
|
||||
}
|
||||
|
||||
// Add promoteBuffers to cursor state
|
||||
if (typeof topologyOptions.promoteBuffers === 'boolean') {
|
||||
this.cursorState.promoteBuffers = topologyOptions.promoteBuffers;
|
||||
} else if (typeof options.promoteBuffers === 'boolean') {
|
||||
this.cursorState.promoteBuffers = options.promoteBuffers;
|
||||
}
|
||||
|
||||
if (topologyOptions.reconnect) {
|
||||
this.cursorState.reconnect = topologyOptions.reconnect;
|
||||
}
|
||||
|
||||
// Logger
|
||||
this.logger = Logger('Cursor', topologyOptions);
|
||||
|
||||
//
|
||||
// Did we pass in a cursor id
|
||||
if (typeof cmd === 'number') {
|
||||
this.cursorState.cursorId = Long.fromNumber(cmd);
|
||||
this.cursorState.lastCursorId = this.cursorState.cursorId;
|
||||
} else if (cmd instanceof Long) {
|
||||
this.cursorState.cursorId = cmd;
|
||||
this.cursorState.lastCursorId = cmd;
|
||||
}
|
||||
};
|
||||
|
||||
Cursor.prototype.setCursorBatchSize = function(value) {
|
||||
this.cursorState.batchSize = value;
|
||||
};
|
||||
|
||||
Cursor.prototype.cursorBatchSize = function() {
|
||||
return this.cursorState.batchSize;
|
||||
};
|
||||
|
||||
Cursor.prototype.setCursorLimit = function(value) {
|
||||
this.cursorState.limit = value;
|
||||
};
|
||||
|
||||
Cursor.prototype.cursorLimit = function() {
|
||||
return this.cursorState.limit;
|
||||
};
|
||||
|
||||
Cursor.prototype.setCursorSkip = function(value) {
|
||||
this.cursorState.skip = value;
|
||||
};
|
||||
|
||||
Cursor.prototype.cursorSkip = function() {
|
||||
return this.cursorState.skip;
|
||||
};
|
||||
|
||||
Cursor.prototype._endSession = function(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
options = options || {};
|
||||
|
||||
const session = this.cursorState.session;
|
||||
|
||||
if (session && (options.force || session.owner === this)) {
|
||||
this.cursorState.session = undefined;
|
||||
session.endSession(callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (callback) {
|
||||
callback();
|
||||
}
|
||||
return false;
|
||||
};
|
||||
|
||||
//
|
||||
// Handle callback (including any exceptions thrown)
|
||||
var handleCallback = function(callback, err, result) {
|
||||
try {
|
||||
callback(err, result);
|
||||
} catch (err) {
|
||||
process.nextTick(function() {
|
||||
throw err;
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
// Internal methods
|
||||
Cursor.prototype._find = function(callback) {
|
||||
var self = this;
|
||||
|
||||
if (self.logger.isDebug()) {
|
||||
self.logger.debug(
|
||||
f(
|
||||
'issue initial query [%s] with flags [%s]',
|
||||
JSON.stringify(self.cmd),
|
||||
JSON.stringify(self.query)
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
var queryCallback = function(err, r) {
|
||||
if (err) return callback(err);
|
||||
|
||||
// Get the raw message
|
||||
var result = r.message;
|
||||
|
||||
// Query failure bit set
|
||||
if (result.queryFailure) {
|
||||
return callback(new MongoError(result.documents[0]), null);
|
||||
}
|
||||
|
||||
// Check if we have a command cursor
|
||||
if (
|
||||
Array.isArray(result.documents) &&
|
||||
result.documents.length === 1 &&
|
||||
(!self.cmd.find || (self.cmd.find && self.cmd.virtual === false)) &&
|
||||
(typeof result.documents[0].cursor !== 'string' ||
|
||||
result.documents[0]['$err'] ||
|
||||
result.documents[0]['errmsg'] ||
|
||||
Array.isArray(result.documents[0].result))
|
||||
) {
|
||||
// We have a an error document return the error
|
||||
if (result.documents[0]['$err'] || result.documents[0]['errmsg']) {
|
||||
return callback(new MongoError(result.documents[0]), null);
|
||||
}
|
||||
|
||||
// We have a cursor document
|
||||
if (result.documents[0].cursor != null && typeof result.documents[0].cursor !== 'string') {
|
||||
var id = result.documents[0].cursor.id;
|
||||
// If we have a namespace change set the new namespace for getmores
|
||||
if (result.documents[0].cursor.ns) {
|
||||
self.ns = result.documents[0].cursor.ns;
|
||||
}
|
||||
// Promote id to long if needed
|
||||
self.cursorState.cursorId = typeof id === 'number' ? Long.fromNumber(id) : id;
|
||||
self.cursorState.lastCursorId = self.cursorState.cursorId;
|
||||
self.cursorState.operationTime = result.documents[0].operationTime;
|
||||
// If we have a firstBatch set it
|
||||
if (Array.isArray(result.documents[0].cursor.firstBatch)) {
|
||||
self.cursorState.documents = result.documents[0].cursor.firstBatch; //.reverse();
|
||||
}
|
||||
|
||||
// Return after processing command cursor
|
||||
return callback(null, result);
|
||||
}
|
||||
|
||||
if (Array.isArray(result.documents[0].result)) {
|
||||
self.cursorState.documents = result.documents[0].result;
|
||||
self.cursorState.cursorId = Long.ZERO;
|
||||
return callback(null, result);
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise fall back to regular find path
|
||||
self.cursorState.cursorId = result.cursorId;
|
||||
self.cursorState.documents = result.documents;
|
||||
self.cursorState.lastCursorId = result.cursorId;
|
||||
|
||||
// Transform the results with passed in transformation method if provided
|
||||
if (self.cursorState.transforms && typeof self.cursorState.transforms.query === 'function') {
|
||||
self.cursorState.documents = self.cursorState.transforms.query(result);
|
||||
}
|
||||
|
||||
// Return callback
|
||||
callback(null, result);
|
||||
};
|
||||
|
||||
// Options passed to the pool
|
||||
var queryOptions = {};
|
||||
|
||||
// If we have a raw query decorate the function
|
||||
if (self.options.raw || self.cmd.raw) {
|
||||
// queryCallback.raw = self.options.raw || self.cmd.raw;
|
||||
queryOptions.raw = self.options.raw || self.cmd.raw;
|
||||
}
|
||||
|
||||
// Do we have documentsReturnedIn set on the query
|
||||
if (typeof self.query.documentsReturnedIn === 'string') {
|
||||
// queryCallback.documentsReturnedIn = self.query.documentsReturnedIn;
|
||||
queryOptions.documentsReturnedIn = self.query.documentsReturnedIn;
|
||||
}
|
||||
|
||||
// Add promote Long value if defined
|
||||
if (typeof self.cursorState.promoteLongs === 'boolean') {
|
||||
queryOptions.promoteLongs = self.cursorState.promoteLongs;
|
||||
}
|
||||
|
||||
// Add promote values if defined
|
||||
if (typeof self.cursorState.promoteValues === 'boolean') {
|
||||
queryOptions.promoteValues = self.cursorState.promoteValues;
|
||||
}
|
||||
|
||||
// Add promote values if defined
|
||||
if (typeof self.cursorState.promoteBuffers === 'boolean') {
|
||||
queryOptions.promoteBuffers = self.cursorState.promoteBuffers;
|
||||
}
|
||||
|
||||
if (typeof self.cursorState.session === 'object') {
|
||||
queryOptions.session = self.cursorState.session;
|
||||
}
|
||||
|
||||
// Write the initial command out
|
||||
self.server.s.pool.write(self.query, queryOptions, queryCallback);
|
||||
};
|
||||
|
||||
Cursor.prototype._getmore = function(callback) {
|
||||
if (this.logger.isDebug())
|
||||
this.logger.debug(f('schedule getMore call for query [%s]', JSON.stringify(this.query)));
|
||||
// Determine if it's a raw query
|
||||
var raw = this.options.raw || this.cmd.raw;
|
||||
|
||||
// Set the current batchSize
|
||||
var batchSize = this.cursorState.batchSize;
|
||||
if (
|
||||
this.cursorState.limit > 0 &&
|
||||
this.cursorState.currentLimit + batchSize > this.cursorState.limit
|
||||
) {
|
||||
batchSize = this.cursorState.limit - this.cursorState.currentLimit;
|
||||
}
|
||||
|
||||
// Default pool
|
||||
var pool = this.server.s.pool;
|
||||
|
||||
// We have a wire protocol handler
|
||||
this.server.wireProtocolHandler.getMore(
|
||||
this.bson,
|
||||
this.ns,
|
||||
this.cursorState,
|
||||
batchSize,
|
||||
raw,
|
||||
pool,
|
||||
this.options,
|
||||
callback
|
||||
);
|
||||
};
|
||||
|
||||
/**
|
||||
* Clone the cursor
|
||||
* @method
|
||||
* @return {Cursor}
|
||||
*/
|
||||
Cursor.prototype.clone = function() {
|
||||
return this.topology.cursor(this.ns, this.cmd, this.options);
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if the cursor is dead
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor is dead or not
|
||||
*/
|
||||
Cursor.prototype.isDead = function() {
|
||||
return this.cursorState.dead === true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if the cursor was killed by the application
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor was killed by the application
|
||||
*/
|
||||
Cursor.prototype.isKilled = function() {
|
||||
return this.cursorState.killed === true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if the cursor notified it's caller about it's death
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor notified the callback
|
||||
*/
|
||||
Cursor.prototype.isNotified = function() {
|
||||
return this.cursorState.notified === true;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns current buffered documents length
|
||||
* @method
|
||||
* @return {number} The number of items in the buffered documents
|
||||
*/
|
||||
Cursor.prototype.bufferedCount = function() {
|
||||
return this.cursorState.documents.length - this.cursorState.cursorIndex;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns current buffered documents
|
||||
* @method
|
||||
* @return {Array} An array of buffered documents
|
||||
*/
|
||||
Cursor.prototype.readBufferedDocuments = function(number) {
|
||||
var unreadDocumentsLength = this.cursorState.documents.length - this.cursorState.cursorIndex;
|
||||
var length = number < unreadDocumentsLength ? number : unreadDocumentsLength;
|
||||
var elements = this.cursorState.documents.slice(
|
||||
this.cursorState.cursorIndex,
|
||||
this.cursorState.cursorIndex + length
|
||||
);
|
||||
|
||||
// Transform the doc with passed in transformation method if provided
|
||||
if (this.cursorState.transforms && typeof this.cursorState.transforms.doc === 'function') {
|
||||
// Transform all the elements
|
||||
for (var i = 0; i < elements.length; i++) {
|
||||
elements[i] = this.cursorState.transforms.doc(elements[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure we do not return any more documents than the limit imposed
|
||||
// Just return the number of elements up to the limit
|
||||
if (
|
||||
this.cursorState.limit > 0 &&
|
||||
this.cursorState.currentLimit + elements.length > this.cursorState.limit
|
||||
) {
|
||||
elements = elements.slice(0, this.cursorState.limit - this.cursorState.currentLimit);
|
||||
this.kill();
|
||||
}
|
||||
|
||||
// Adjust current limit
|
||||
this.cursorState.currentLimit = this.cursorState.currentLimit + elements.length;
|
||||
this.cursorState.cursorIndex = this.cursorState.cursorIndex + elements.length;
|
||||
|
||||
// Return elements
|
||||
return elements;
|
||||
};
|
||||
|
||||
/**
|
||||
* Kill the cursor
|
||||
* @method
|
||||
* @param {resultCallback} callback A callback function
|
||||
*/
|
||||
Cursor.prototype.kill = function(callback) {
|
||||
// Set cursor to dead
|
||||
this.cursorState.dead = true;
|
||||
this.cursorState.killed = true;
|
||||
// Remove documents
|
||||
this.cursorState.documents = [];
|
||||
|
||||
// If no cursor id just return
|
||||
if (
|
||||
this.cursorState.cursorId == null ||
|
||||
this.cursorState.cursorId.isZero() ||
|
||||
this.cursorState.init === false
|
||||
) {
|
||||
if (callback) callback(null, null);
|
||||
return;
|
||||
}
|
||||
|
||||
// Default pool
|
||||
var pool = this.server.s.pool;
|
||||
// Execute command
|
||||
this.server.wireProtocolHandler.killCursor(this.bson, this.ns, this.cursorState, pool, callback);
|
||||
};
|
||||
|
||||
/**
|
||||
* Resets the cursor
|
||||
* @method
|
||||
* @return {null}
|
||||
*/
|
||||
Cursor.prototype.rewind = function() {
|
||||
if (this.cursorState.init) {
|
||||
if (!this.cursorState.dead) {
|
||||
this.kill();
|
||||
}
|
||||
|
||||
this.cursorState.currentLimit = 0;
|
||||
this.cursorState.init = false;
|
||||
this.cursorState.dead = false;
|
||||
this.cursorState.killed = false;
|
||||
this.cursorState.notified = false;
|
||||
this.cursorState.documents = [];
|
||||
this.cursorState.cursorId = null;
|
||||
this.cursorState.cursorIndex = 0;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if the pool is dead and return error
|
||||
*/
|
||||
var isConnectionDead = function(self, callback) {
|
||||
if (self.pool && self.pool.isDestroyed()) {
|
||||
self.cursorState.killed = true;
|
||||
const err = new MongoNetworkError(
|
||||
f('connection to host %s:%s was destroyed', self.pool.host, self.pool.port)
|
||||
);
|
||||
_setCursorNotifiedImpl(self, () => callback(err));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if the cursor is dead but was not explicitly killed by user
|
||||
*/
|
||||
var isCursorDeadButNotkilled = function(self, callback) {
|
||||
// Cursor is dead but not marked killed, return null
|
||||
if (self.cursorState.dead && !self.cursorState.killed) {
|
||||
self.cursorState.killed = true;
|
||||
setCursorNotified(self, callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if the cursor is dead and was killed by user
|
||||
*/
|
||||
var isCursorDeadAndKilled = function(self, callback) {
|
||||
if (self.cursorState.dead && self.cursorState.killed) {
|
||||
handleCallback(callback, new MongoError('cursor is dead'));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if the cursor was killed by the user
|
||||
*/
|
||||
var isCursorKilled = function(self, callback) {
|
||||
if (self.cursorState.killed) {
|
||||
setCursorNotified(self, callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* Mark cursor as being dead and notified
|
||||
*/
|
||||
var setCursorDeadAndNotified = function(self, callback) {
|
||||
self.cursorState.dead = true;
|
||||
setCursorNotified(self, callback);
|
||||
};
|
||||
|
||||
/**
|
||||
* Mark cursor as being notified
|
||||
*/
|
||||
var setCursorNotified = function(self, callback) {
|
||||
_setCursorNotifiedImpl(self, () => handleCallback(callback, null, null));
|
||||
};
|
||||
|
||||
var _setCursorNotifiedImpl = function(self, callback) {
|
||||
self.cursorState.notified = true;
|
||||
self.cursorState.documents = [];
|
||||
self.cursorState.cursorIndex = 0;
|
||||
if (self._endSession) {
|
||||
return self._endSession(undefined, () => callback());
|
||||
}
|
||||
return callback();
|
||||
};
|
||||
|
||||
var nextFunction = function(self, callback) {
|
||||
// We have notified about it
|
||||
if (self.cursorState.notified) {
|
||||
return callback(new Error('cursor is exhausted'));
|
||||
}
|
||||
|
||||
// Cursor is killed return null
|
||||
if (isCursorKilled(self, callback)) return;
|
||||
|
||||
// Cursor is dead but not marked killed, return null
|
||||
if (isCursorDeadButNotkilled(self, callback)) return;
|
||||
|
||||
// We have a dead and killed cursor, attempting to call next should error
|
||||
if (isCursorDeadAndKilled(self, callback)) return;
|
||||
|
||||
// We have just started the cursor
|
||||
if (!self.cursorState.init) {
|
||||
return initializeCursor(self, callback);
|
||||
}
|
||||
|
||||
// If we don't have a cursorId execute the first query
|
||||
if (self.cursorState.cursorId == null) {
|
||||
// Check if pool is dead and return if not possible to
|
||||
// execute the query against the db
|
||||
if (isConnectionDead(self, callback)) return;
|
||||
|
||||
// Check if topology is destroyed
|
||||
if (self.topology.isDestroyed())
|
||||
return callback(
|
||||
new MongoNetworkError('connection destroyed, not possible to instantiate cursor')
|
||||
);
|
||||
|
||||
// query, cmd, options, cursorState, callback
|
||||
self._find(function(err) {
|
||||
if (err) return handleCallback(callback, err, null);
|
||||
|
||||
if (self.cursorState.cursorId && self.cursorState.cursorId.isZero() && self._endSession) {
|
||||
self._endSession();
|
||||
}
|
||||
|
||||
if (
|
||||
self.cursorState.documents.length === 0 &&
|
||||
self.cursorState.cursorId &&
|
||||
self.cursorState.cursorId.isZero() &&
|
||||
!self.cmd.tailable &&
|
||||
!self.cmd.awaitData
|
||||
) {
|
||||
return setCursorNotified(self, callback);
|
||||
}
|
||||
|
||||
nextFunction(self, callback);
|
||||
});
|
||||
} else if (
|
||||
self.cursorState.limit > 0 &&
|
||||
self.cursorState.currentLimit >= self.cursorState.limit
|
||||
) {
|
||||
// Ensure we kill the cursor on the server
|
||||
self.kill();
|
||||
// Set cursor in dead and notified state
|
||||
return setCursorDeadAndNotified(self, callback);
|
||||
} else if (
|
||||
self.cursorState.cursorIndex === self.cursorState.documents.length &&
|
||||
!Long.ZERO.equals(self.cursorState.cursorId)
|
||||
) {
|
||||
// Ensure an empty cursor state
|
||||
self.cursorState.documents = [];
|
||||
self.cursorState.cursorIndex = 0;
|
||||
|
||||
// Check if topology is destroyed
|
||||
if (self.topology.isDestroyed())
|
||||
return callback(
|
||||
new MongoNetworkError('connection destroyed, not possible to instantiate cursor')
|
||||
);
|
||||
|
||||
// Check if connection is dead and return if not possible to
|
||||
// execute a getmore on this connection
|
||||
if (isConnectionDead(self, callback)) return;
|
||||
|
||||
// Execute the next get more
|
||||
self._getmore(function(err, doc, connection) {
|
||||
if (err) {
|
||||
if (err instanceof MongoError) {
|
||||
err[mongoErrorContextSymbol].isGetMore = true;
|
||||
}
|
||||
|
||||
return handleCallback(callback, err);
|
||||
}
|
||||
|
||||
if (self.cursorState.cursorId && self.cursorState.cursorId.isZero() && self._endSession) {
|
||||
self._endSession();
|
||||
}
|
||||
|
||||
// Save the returned connection to ensure all getMore's fire over the same connection
|
||||
self.connection = connection;
|
||||
|
||||
// Tailable cursor getMore result, notify owner about it
|
||||
// No attempt is made here to retry, this is left to the user of the
|
||||
// core module to handle to keep core simple
|
||||
if (
|
||||
self.cursorState.documents.length === 0 &&
|
||||
self.cmd.tailable &&
|
||||
Long.ZERO.equals(self.cursorState.cursorId)
|
||||
) {
|
||||
// No more documents in the tailed cursor
|
||||
return handleCallback(
|
||||
callback,
|
||||
new MongoError({
|
||||
message: 'No more documents in tailed cursor',
|
||||
tailable: self.cmd.tailable,
|
||||
awaitData: self.cmd.awaitData
|
||||
})
|
||||
);
|
||||
} else if (
|
||||
self.cursorState.documents.length === 0 &&
|
||||
self.cmd.tailable &&
|
||||
!Long.ZERO.equals(self.cursorState.cursorId)
|
||||
) {
|
||||
return nextFunction(self, callback);
|
||||
}
|
||||
|
||||
if (self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
|
||||
return setCursorDeadAndNotified(self, callback);
|
||||
}
|
||||
|
||||
nextFunction(self, callback);
|
||||
});
|
||||
} else if (
|
||||
self.cursorState.documents.length === self.cursorState.cursorIndex &&
|
||||
self.cmd.tailable &&
|
||||
Long.ZERO.equals(self.cursorState.cursorId)
|
||||
) {
|
||||
return handleCallback(
|
||||
callback,
|
||||
new MongoError({
|
||||
message: 'No more documents in tailed cursor',
|
||||
tailable: self.cmd.tailable,
|
||||
awaitData: self.cmd.awaitData
|
||||
})
|
||||
);
|
||||
} else if (
|
||||
self.cursorState.documents.length === self.cursorState.cursorIndex &&
|
||||
Long.ZERO.equals(self.cursorState.cursorId)
|
||||
) {
|
||||
setCursorDeadAndNotified(self, callback);
|
||||
} else {
|
||||
if (self.cursorState.limit > 0 && self.cursorState.currentLimit >= self.cursorState.limit) {
|
||||
// Ensure we kill the cursor on the server
|
||||
self.kill();
|
||||
// Set cursor in dead and notified state
|
||||
return setCursorDeadAndNotified(self, callback);
|
||||
}
|
||||
|
||||
// Increment the current cursor limit
|
||||
self.cursorState.currentLimit += 1;
|
||||
|
||||
// Get the document
|
||||
var doc = self.cursorState.documents[self.cursorState.cursorIndex++];
|
||||
|
||||
// Doc overflow
|
||||
if (!doc || doc.$err) {
|
||||
// Ensure we kill the cursor on the server
|
||||
self.kill();
|
||||
// Set cursor in dead and notified state
|
||||
return setCursorDeadAndNotified(self, function() {
|
||||
handleCallback(callback, new MongoError(doc ? doc.$err : undefined));
|
||||
});
|
||||
}
|
||||
|
||||
// Transform the doc with passed in transformation method if provided
|
||||
if (self.cursorState.transforms && typeof self.cursorState.transforms.doc === 'function') {
|
||||
doc = self.cursorState.transforms.doc(doc);
|
||||
}
|
||||
|
||||
// Return the document
|
||||
handleCallback(callback, null, doc);
|
||||
}
|
||||
};
|
||||
|
||||
function initializeCursor(cursor, callback) {
|
||||
// Topology is not connected, save the call in the provided store to be
|
||||
// Executed at some point when the handler deems it's reconnected
|
||||
if (!cursor.topology.isConnected(cursor.options)) {
|
||||
// Only need this for single server, because repl sets and mongos
|
||||
// will always continue trying to reconnect
|
||||
if (cursor.topology._type === 'server' && !cursor.topology.s.options.reconnect) {
|
||||
// Reconnect is disabled, so we'll never reconnect
|
||||
return callback(new MongoError('no connection available'));
|
||||
}
|
||||
|
||||
if (cursor.disconnectHandler != null) {
|
||||
if (cursor.topology.isDestroyed()) {
|
||||
// Topology was destroyed, so don't try to wait for it to reconnect
|
||||
return callback(new MongoError('Topology was destroyed'));
|
||||
}
|
||||
|
||||
return cursor.disconnectHandler.addObjectAndMethod(
|
||||
'cursor',
|
||||
cursor,
|
||||
'next',
|
||||
[callback],
|
||||
callback
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
return cursor.topology.selectServer(cursor.options, (err, server) => {
|
||||
if (err) {
|
||||
// Handle the error and add object to next method call
|
||||
if (cursor.disconnectHandler != null) {
|
||||
return cursor.disconnectHandler.addObjectAndMethod(
|
||||
'cursor',
|
||||
cursor,
|
||||
'next',
|
||||
[callback],
|
||||
callback
|
||||
);
|
||||
}
|
||||
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
cursor.server = server;
|
||||
|
||||
// Set as init
|
||||
cursor.cursorState.init = true;
|
||||
|
||||
// error if collation not supported
|
||||
if (collationNotSupported(cursor.server, cursor.cmd)) {
|
||||
return callback(new MongoError(`server ${cursor.server.name} does not support collation`));
|
||||
}
|
||||
|
||||
try {
|
||||
cursor.query = cursor.server.wireProtocolHandler.command(
|
||||
cursor.bson,
|
||||
cursor.ns,
|
||||
cursor.cmd,
|
||||
cursor.cursorState,
|
||||
cursor.topology,
|
||||
cursor.options
|
||||
);
|
||||
|
||||
if (cursor.query instanceof MongoError) {
|
||||
return callback(cursor.query);
|
||||
}
|
||||
|
||||
// call `nextFunction` again now that we are initialized
|
||||
nextFunction(cursor, callback);
|
||||
} catch (err) {
|
||||
return callback(err);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the next document from the cursor
|
||||
* @method
|
||||
* @param {resultCallback} callback A callback function
|
||||
*/
|
||||
Cursor.prototype.next = function(callback) {
|
||||
nextFunction(this, callback);
|
||||
};
|
||||
|
||||
module.exports = Cursor;
|
||||
+146
@@ -0,0 +1,146 @@
|
||||
'use strict';
|
||||
|
||||
const mongoErrorContextSymbol = Symbol('mongoErrorContextSymbol');
|
||||
|
||||
/**
|
||||
* Creates a new MongoError
|
||||
*
|
||||
* @augments Error
|
||||
* @param {Error|string|object} message The error message
|
||||
* @property {string} message The error message
|
||||
* @property {string} stack The error call stack
|
||||
*/
|
||||
class MongoError extends Error {
|
||||
constructor(message) {
|
||||
if (message instanceof Error) {
|
||||
super(message.message);
|
||||
this.stack = message.stack;
|
||||
} else {
|
||||
if (typeof message === 'string') {
|
||||
super(message);
|
||||
} else {
|
||||
super(message.message || message.errmsg || message.$err || 'n/a');
|
||||
for (var name in message) {
|
||||
this[name] = message[name];
|
||||
}
|
||||
}
|
||||
|
||||
Error.captureStackTrace(this, this.constructor);
|
||||
}
|
||||
|
||||
this.name = 'MongoError';
|
||||
this[mongoErrorContextSymbol] = this[mongoErrorContextSymbol] || {};
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new MongoError object
|
||||
*
|
||||
* @param {Error|string|object} options The options used to create the error.
|
||||
* @return {MongoError} A MongoError instance
|
||||
* @deprecated Use `new MongoError()` instead.
|
||||
*/
|
||||
static create(options) {
|
||||
return new MongoError(options);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates a new MongoNetworkError
|
||||
*
|
||||
* @param {Error|string|object} message The error message
|
||||
* @property {string} message The error message
|
||||
* @property {string} stack The error call stack
|
||||
*/
|
||||
class MongoNetworkError extends MongoError {
|
||||
constructor(message) {
|
||||
super(message);
|
||||
this.name = 'MongoNetworkError';
|
||||
|
||||
// This is added as part of the transactions specification
|
||||
this.errorLabels = ['TransientTransactionError'];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An error used when attempting to parse a value (like a connection string)
|
||||
*
|
||||
* @param {Error|string|object} message The error message
|
||||
* @property {string} message The error message
|
||||
*/
|
||||
class MongoParseError extends MongoError {
|
||||
constructor(message) {
|
||||
super(message);
|
||||
this.name = 'MongoParseError';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An error signifying a timeout event
|
||||
*
|
||||
* @param {Error|string|object} message The error message
|
||||
* @property {string} message The error message
|
||||
*/
|
||||
class MongoTimeoutError extends MongoError {
|
||||
constructor(message) {
|
||||
super(message);
|
||||
this.name = 'MongoTimeoutError';
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* An error thrown when the server reports a writeConcernError
|
||||
*
|
||||
* @param {Error|string|object} message The error message
|
||||
* @param {object} result The result document (provided if ok: 1)
|
||||
* @property {string} message The error message
|
||||
* @property {object} [result] The result document (provided if ok: 1)
|
||||
*/
|
||||
class MongoWriteConcernError extends MongoError {
|
||||
constructor(message, result) {
|
||||
super(message);
|
||||
this.name = 'MongoWriteConcernError';
|
||||
|
||||
if (result != null) {
|
||||
this.result = result;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// see: https://github.com/mongodb/specifications/blob/master/source/retryable-writes/retryable-writes.rst#terms
|
||||
const RETRYABLE_ERROR_CODES = new Set([
|
||||
6, // HostUnreachable
|
||||
7, // HostNotFound
|
||||
89, // NetworkTimeout
|
||||
91, // ShutdownInProgress
|
||||
189, // PrimarySteppedDown
|
||||
9001, // SocketException
|
||||
10107, // NotMaster
|
||||
11600, // InterruptedAtShutdown
|
||||
11602, // InterruptedDueToReplStateChange
|
||||
13435, // NotMasterNoSlaveOk
|
||||
13436 // NotMasterOrSecondary
|
||||
]);
|
||||
|
||||
/**
|
||||
* Determines whether an error is something the driver should attempt to retry
|
||||
*
|
||||
* @param {(MongoError|Error})} error
|
||||
*/
|
||||
function isRetryableError(error) {
|
||||
return (
|
||||
RETRYABLE_ERROR_CODES.has(error.code) ||
|
||||
error instanceof MongoNetworkError ||
|
||||
error.message.match(/not master/) ||
|
||||
error.message.match(/node is recovering/)
|
||||
);
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
MongoError,
|
||||
MongoNetworkError,
|
||||
MongoParseError,
|
||||
MongoTimeoutError,
|
||||
MongoWriteConcernError,
|
||||
mongoErrorContextSymbol,
|
||||
isRetryableError
|
||||
};
|
||||
+749
@@ -0,0 +1,749 @@
|
||||
'use strict';
|
||||
|
||||
const Logger = require('../connection/logger');
|
||||
const BSON = require('../connection/utils').retrieveBSON();
|
||||
const MongoError = require('../error').MongoError;
|
||||
const MongoNetworkError = require('../error').MongoNetworkError;
|
||||
const mongoErrorContextSymbol = require('../error').mongoErrorContextSymbol;
|
||||
const Long = BSON.Long;
|
||||
const deprecate = require('util').deprecate;
|
||||
const readPreferenceServerSelector = require('./server_selectors').readPreferenceServerSelector;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
|
||||
/**
|
||||
* Handle callback (including any exceptions thrown)
|
||||
*/
|
||||
function handleCallback(callback, err, result) {
|
||||
try {
|
||||
callback(err, result);
|
||||
} catch (err) {
|
||||
process.nextTick(function() {
|
||||
throw err;
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* This is a cursor results callback
|
||||
*
|
||||
* @callback resultCallback
|
||||
* @param {error} error An error object. Set to null if no error present
|
||||
* @param {object} document
|
||||
*/
|
||||
|
||||
/**
|
||||
* An internal class that embodies a cursor on MongoDB, allowing for iteration over the
|
||||
* results returned from a query.
|
||||
*
|
||||
* @property {number} cursorBatchSize The current cursorBatchSize for the cursor
|
||||
* @property {number} cursorLimit The current cursorLimit for the cursor
|
||||
* @property {number} cursorSkip The current cursorSkip for the cursor
|
||||
*/
|
||||
class Cursor {
|
||||
/**
|
||||
* Create a cursor
|
||||
*
|
||||
* @param {object} bson An instance of the BSON parser
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {{object}|Long} cmd The selector (can be a command or a cursorId)
|
||||
* @param {object} [options=null] Optional settings.
|
||||
* @param {object} [options.batchSize=1000] Batchsize for the operation
|
||||
* @param {array} [options.documents=[]] Initial documents list for cursor
|
||||
* @param {object} [options.transforms=null] Transform methods for the cursor results
|
||||
* @param {function} [options.transforms.query] Transform the value returned from the initial query
|
||||
* @param {function} [options.transforms.doc] Transform each document returned from Cursor.prototype.next
|
||||
* @param {object} topology The server topology instance.
|
||||
* @param {object} topologyOptions The server topology options.
|
||||
*/
|
||||
constructor(bson, ns, cmd, options, topology, topologyOptions) {
|
||||
options = options || {};
|
||||
|
||||
// Cursor pool
|
||||
this.pool = null;
|
||||
// Cursor server
|
||||
this.server = null;
|
||||
|
||||
// Do we have a not connected handler
|
||||
this.disconnectHandler = options.disconnectHandler;
|
||||
|
||||
// Set local values
|
||||
this.bson = bson;
|
||||
this.ns = ns;
|
||||
this.cmd = cmd;
|
||||
this.options = options;
|
||||
this.topology = topology;
|
||||
|
||||
// All internal state
|
||||
this.s = {
|
||||
cursorId: null,
|
||||
cmd: cmd,
|
||||
documents: options.documents || [],
|
||||
cursorIndex: 0,
|
||||
dead: false,
|
||||
killed: false,
|
||||
init: false,
|
||||
notified: false,
|
||||
limit: options.limit || cmd.limit || 0,
|
||||
skip: options.skip || cmd.skip || 0,
|
||||
batchSize: options.batchSize || cmd.batchSize || 1000,
|
||||
currentLimit: 0,
|
||||
// Result field name if not a cursor (contains the array of results)
|
||||
transforms: options.transforms
|
||||
};
|
||||
|
||||
if (typeof options.session === 'object') {
|
||||
this.s.session = options.session;
|
||||
}
|
||||
|
||||
// Add promoteLong to cursor state
|
||||
if (typeof topologyOptions.promoteLongs === 'boolean') {
|
||||
this.s.promoteLongs = topologyOptions.promoteLongs;
|
||||
} else if (typeof options.promoteLongs === 'boolean') {
|
||||
this.s.promoteLongs = options.promoteLongs;
|
||||
}
|
||||
|
||||
// Add promoteValues to cursor state
|
||||
if (typeof topologyOptions.promoteValues === 'boolean') {
|
||||
this.s.promoteValues = topologyOptions.promoteValues;
|
||||
} else if (typeof options.promoteValues === 'boolean') {
|
||||
this.s.promoteValues = options.promoteValues;
|
||||
}
|
||||
|
||||
// Add promoteBuffers to cursor state
|
||||
if (typeof topologyOptions.promoteBuffers === 'boolean') {
|
||||
this.s.promoteBuffers = topologyOptions.promoteBuffers;
|
||||
} else if (typeof options.promoteBuffers === 'boolean') {
|
||||
this.s.promoteBuffers = options.promoteBuffers;
|
||||
}
|
||||
|
||||
if (topologyOptions.reconnect) {
|
||||
this.s.reconnect = topologyOptions.reconnect;
|
||||
}
|
||||
|
||||
// Logger
|
||||
this.logger = Logger('Cursor', topologyOptions);
|
||||
|
||||
//
|
||||
// Did we pass in a cursor id
|
||||
if (typeof cmd === 'number') {
|
||||
this.s.cursorId = Long.fromNumber(cmd);
|
||||
this.s.lastCursorId = this.s.cursorId;
|
||||
} else if (cmd instanceof Long) {
|
||||
this.s.cursorId = cmd;
|
||||
this.s.lastCursorId = cmd;
|
||||
}
|
||||
}
|
||||
|
||||
setCursorBatchSize(value) {
|
||||
this.s.batchSize = value;
|
||||
}
|
||||
|
||||
cursorBatchSize() {
|
||||
return this.s.batchSize;
|
||||
}
|
||||
|
||||
setCursorLimit(value) {
|
||||
this.s.limit = value;
|
||||
}
|
||||
|
||||
cursorLimit() {
|
||||
return this.s.limit;
|
||||
}
|
||||
|
||||
setCursorSkip(value) {
|
||||
this.s.skip = value;
|
||||
}
|
||||
|
||||
cursorSkip() {
|
||||
return this.s.skip;
|
||||
}
|
||||
|
||||
_endSession(options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
}
|
||||
options = options || {};
|
||||
|
||||
const session = this.s.session;
|
||||
if (session && (options.force || session.owner === this)) {
|
||||
this.s.session = undefined;
|
||||
session.endSession(callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
if (callback) {
|
||||
callback();
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Clone the cursor
|
||||
* @method
|
||||
* @return {Cursor}
|
||||
*/
|
||||
clone() {
|
||||
return this.topology.cursor(this.ns, this.cmd, this.options);
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the cursor is dead
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor is dead or not
|
||||
*/
|
||||
isDead() {
|
||||
return this.s.dead === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the cursor was killed by the application
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor was killed by the application
|
||||
*/
|
||||
isKilled() {
|
||||
return this.s.killed === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Checks if the cursor notified it's caller about it's death
|
||||
* @method
|
||||
* @return {boolean} A boolean signifying if the cursor notified the callback
|
||||
*/
|
||||
isNotified() {
|
||||
return this.s.notified === true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns current buffered documents length
|
||||
* @method
|
||||
* @return {number} The number of items in the buffered documents
|
||||
*/
|
||||
bufferedCount() {
|
||||
return this.s.documents.length - this.s.cursorIndex;
|
||||
}
|
||||
|
||||
/**
|
||||
* Kill the cursor
|
||||
*
|
||||
* @param {resultCallback} callback A callback function
|
||||
*/
|
||||
kill(callback) {
|
||||
// Set cursor to dead
|
||||
this.s.dead = true;
|
||||
this.s.killed = true;
|
||||
// Remove documents
|
||||
this.s.documents = [];
|
||||
|
||||
// If no cursor id just return
|
||||
if (this.s.cursorId == null || this.s.cursorId.isZero() || this.s.init === false) {
|
||||
if (callback) callback(null, null);
|
||||
return;
|
||||
}
|
||||
|
||||
// Default pool
|
||||
const pool = this.s.server.s.pool;
|
||||
|
||||
// Execute command
|
||||
this.s.server.s.wireProtocolHandler.killCursor(this.bson, this.ns, this.s, pool, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Resets the cursor
|
||||
*/
|
||||
rewind() {
|
||||
if (this.s.init) {
|
||||
if (!this.s.dead) {
|
||||
this.kill();
|
||||
}
|
||||
|
||||
this.s.currentLimit = 0;
|
||||
this.s.init = false;
|
||||
this.s.dead = false;
|
||||
this.s.killed = false;
|
||||
this.s.notified = false;
|
||||
this.s.documents = [];
|
||||
this.s.cursorId = null;
|
||||
this.s.cursorIndex = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns current buffered documents
|
||||
* @method
|
||||
* @return {Array} An array of buffered documents
|
||||
*/
|
||||
readBufferedDocuments(number) {
|
||||
const unreadDocumentsLength = this.s.documents.length - this.s.cursorIndex;
|
||||
const length = number < unreadDocumentsLength ? number : unreadDocumentsLength;
|
||||
let elements = this.s.documents.slice(this.s.cursorIndex, this.s.cursorIndex + length);
|
||||
|
||||
// Transform the doc with passed in transformation method if provided
|
||||
if (this.s.transforms && typeof this.s.transforms.doc === 'function') {
|
||||
// Transform all the elements
|
||||
for (let i = 0; i < elements.length; i++) {
|
||||
elements[i] = this.s.transforms.doc(elements[i]);
|
||||
}
|
||||
}
|
||||
|
||||
// Ensure we do not return any more documents than the limit imposed
|
||||
// Just return the number of elements up to the limit
|
||||
if (this.s.limit > 0 && this.s.currentLimit + elements.length > this.s.limit) {
|
||||
elements = elements.slice(0, this.s.limit - this.s.currentLimit);
|
||||
this.kill();
|
||||
}
|
||||
|
||||
// Adjust current limit
|
||||
this.s.currentLimit = this.s.currentLimit + elements.length;
|
||||
this.s.cursorIndex = this.s.cursorIndex + elements.length;
|
||||
|
||||
// Return elements
|
||||
return elements;
|
||||
}
|
||||
|
||||
/**
|
||||
* Retrieve the next document from the cursor
|
||||
*
|
||||
* @param {resultCallback} callback A callback function
|
||||
*/
|
||||
next(callback) {
|
||||
nextFunction(this, callback);
|
||||
}
|
||||
}
|
||||
|
||||
Cursor.prototype._find = deprecate(
|
||||
callback => _find(this, callback),
|
||||
'_find() is deprecated, please stop using it'
|
||||
);
|
||||
|
||||
Cursor.prototype._getmore = deprecate(
|
||||
callback => _getmore(this, callback),
|
||||
'_getmore() is deprecated, please stop using it'
|
||||
);
|
||||
|
||||
function _getmore(cursor, callback) {
|
||||
if (cursor.logger.isDebug()) {
|
||||
cursor.logger.debug(`schedule getMore call for query [${JSON.stringify(cursor.query)}]`);
|
||||
}
|
||||
|
||||
// Determine if it's a raw query
|
||||
const raw = cursor.options.raw || cursor.cmd.raw;
|
||||
|
||||
// Set the current batchSize
|
||||
let batchSize = cursor.s.batchSize;
|
||||
if (cursor.s.limit > 0 && cursor.s.currentLimit + batchSize > cursor.s.limit) {
|
||||
batchSize = cursor.s.limit - cursor.s.currentLimit;
|
||||
}
|
||||
|
||||
// Default pool
|
||||
const pool = cursor.s.server.s.pool;
|
||||
|
||||
// We have a wire protocol handler
|
||||
cursor.s.server.s.wireProtocolHandler.getMore(
|
||||
cursor.bson,
|
||||
cursor.ns,
|
||||
cursor.s,
|
||||
batchSize,
|
||||
raw,
|
||||
pool,
|
||||
cursor.options,
|
||||
callback
|
||||
);
|
||||
}
|
||||
|
||||
function _find(cursor, callback) {
|
||||
if (cursor.logger.isDebug()) {
|
||||
cursor.logger.debug(
|
||||
`issue initial query [${JSON.stringify(cursor.cmd)}] with flags [${JSON.stringify(
|
||||
cursor.query
|
||||
)}]`
|
||||
);
|
||||
}
|
||||
|
||||
const queryCallback = (err, r) => {
|
||||
if (err) return callback(err);
|
||||
|
||||
// Get the raw message
|
||||
const result = r.message;
|
||||
|
||||
// Query failure bit set
|
||||
if (result.queryFailure) {
|
||||
return callback(new MongoError(result.documents[0]), null);
|
||||
}
|
||||
|
||||
// Check if we have a command cursor
|
||||
if (
|
||||
Array.isArray(result.documents) &&
|
||||
result.documents.length === 1 &&
|
||||
(!cursor.cmd.find || (cursor.cmd.find && cursor.cmd.virtual === false)) &&
|
||||
(result.documents[0].cursor !== 'string' ||
|
||||
result.documents[0]['$err'] ||
|
||||
result.documents[0]['errmsg'] ||
|
||||
Array.isArray(result.documents[0].result))
|
||||
) {
|
||||
// We have a an error document return the error
|
||||
if (result.documents[0]['$err'] || result.documents[0]['errmsg']) {
|
||||
return callback(new MongoError(result.documents[0]), null);
|
||||
}
|
||||
|
||||
// We have a cursor document
|
||||
if (result.documents[0].cursor != null && typeof result.documents[0].cursor !== 'string') {
|
||||
const id = result.documents[0].cursor.id;
|
||||
// If we have a namespace change set the new namespace for getmores
|
||||
if (result.documents[0].cursor.ns) {
|
||||
cursor.ns = result.documents[0].cursor.ns;
|
||||
}
|
||||
// Promote id to long if needed
|
||||
cursor.s.cursorId = typeof id === 'number' ? Long.fromNumber(id) : id;
|
||||
cursor.s.lastCursorId = cursor.s.cursorId;
|
||||
// If we have a firstBatch set it
|
||||
if (Array.isArray(result.documents[0].cursor.firstBatch)) {
|
||||
cursor.s.documents = result.documents[0].cursor.firstBatch;
|
||||
}
|
||||
|
||||
// Return after processing command cursor
|
||||
return callback(null, result);
|
||||
}
|
||||
|
||||
if (Array.isArray(result.documents[0].result)) {
|
||||
cursor.s.documents = result.documents[0].result;
|
||||
cursor.s.cursorId = Long.ZERO;
|
||||
return callback(null, result);
|
||||
}
|
||||
}
|
||||
|
||||
// Otherwise fall back to regular find path
|
||||
cursor.s.cursorId = result.cursorId;
|
||||
cursor.s.documents = result.documents;
|
||||
cursor.s.lastCursorId = result.cursorId;
|
||||
|
||||
// Transform the results with passed in transformation method if provided
|
||||
if (cursor.s.transforms && typeof cursor.s.transforms.query === 'function') {
|
||||
cursor.s.documents = cursor.s.transforms.query(result);
|
||||
}
|
||||
|
||||
// Return callback
|
||||
callback(null, result);
|
||||
};
|
||||
|
||||
// Options passed to the pool
|
||||
const queryOptions = {};
|
||||
|
||||
// If we have a raw query decorate the function
|
||||
if (cursor.options.raw || cursor.cmd.raw) {
|
||||
queryOptions.raw = cursor.options.raw || cursor.cmd.raw;
|
||||
}
|
||||
|
||||
// Do we have documentsReturnedIn set on the query
|
||||
if (typeof cursor.query.documentsReturnedIn === 'string') {
|
||||
queryOptions.documentsReturnedIn = cursor.query.documentsReturnedIn;
|
||||
}
|
||||
|
||||
// Add promote Long value if defined
|
||||
if (typeof cursor.s.promoteLongs === 'boolean') {
|
||||
queryOptions.promoteLongs = cursor.s.promoteLongs;
|
||||
}
|
||||
|
||||
// Add promote values if defined
|
||||
if (typeof cursor.s.promoteValues === 'boolean') {
|
||||
queryOptions.promoteValues = cursor.s.promoteValues;
|
||||
}
|
||||
|
||||
// Add promote values if defined
|
||||
if (typeof cursor.s.promoteBuffers === 'boolean') {
|
||||
queryOptions.promoteBuffers = cursor.s.promoteBuffers;
|
||||
}
|
||||
|
||||
if (typeof cursor.s.session === 'object') {
|
||||
queryOptions.session = cursor.s.session;
|
||||
}
|
||||
|
||||
// Write the initial command out
|
||||
cursor.s.server.s.pool.write(cursor.query, queryOptions, queryCallback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate if the pool is dead and return error
|
||||
*/
|
||||
function isConnectionDead(cursor, callback) {
|
||||
if (cursor.pool && cursor.pool.isDestroyed()) {
|
||||
cursor.s.killed = true;
|
||||
const err = new MongoNetworkError(
|
||||
`connection to host ${cursor.pool.host}:${cursor.pool.port} was destroyed`
|
||||
);
|
||||
_setCursorNotifiedImpl(cursor, () => callback(err));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate if the cursor is dead but was not explicitly killed by user
|
||||
*/
|
||||
function isCursorDeadButNotkilled(cursor, callback) {
|
||||
// Cursor is dead but not marked killed, return null
|
||||
if (cursor.s.dead && !cursor.s.killed) {
|
||||
cursor.s.killed = true;
|
||||
setCursorNotified(cursor, callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate if the cursor is dead and was killed by user
|
||||
*/
|
||||
function isCursorDeadAndKilled(cursor, callback) {
|
||||
if (cursor.s.dead && cursor.s.killed) {
|
||||
handleCallback(callback, new MongoError('cursor is dead'));
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Validate if the cursor was killed by the user
|
||||
*/
|
||||
function isCursorKilled(cursor, callback) {
|
||||
if (cursor.s.killed) {
|
||||
setCursorNotified(cursor, callback);
|
||||
return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark cursor as being dead and notified
|
||||
*/
|
||||
function setCursorDeadAndNotified(cursor, callback) {
|
||||
cursor.s.dead = true;
|
||||
setCursorNotified(cursor, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Mark cursor as being notified
|
||||
*/
|
||||
function setCursorNotified(cursor, callback) {
|
||||
_setCursorNotifiedImpl(cursor, () => handleCallback(callback, null, null));
|
||||
}
|
||||
|
||||
function _setCursorNotifiedImpl(cursor, callback) {
|
||||
cursor.s.notified = true;
|
||||
cursor.s.documents = [];
|
||||
cursor.s.cursorIndex = 0;
|
||||
if (cursor._endSession) {
|
||||
return cursor._endSession(undefined, () => callback());
|
||||
}
|
||||
return callback();
|
||||
}
|
||||
|
||||
function initializeCursorAndRetryNext(cursor, callback) {
|
||||
cursor.topology.selectServer(
|
||||
readPreferenceServerSelector(cursor.options.readPreference || ReadPreference.primary),
|
||||
(err, server) => {
|
||||
if (err) {
|
||||
callback(err, null);
|
||||
return;
|
||||
}
|
||||
|
||||
cursor.s.server = server;
|
||||
cursor.s.init = true;
|
||||
|
||||
// check if server supports collation
|
||||
// NOTE: this should be a part of the selection predicate!
|
||||
if (cursor.cmd && cursor.cmd.collation && cursor.server.description.maxWireVersion < 5) {
|
||||
callback(new MongoError(`server ${cursor.server.name} does not support collation`));
|
||||
return;
|
||||
}
|
||||
|
||||
try {
|
||||
cursor.query = cursor.s.server.s.wireProtocolHandler.command(
|
||||
cursor.bson,
|
||||
cursor.ns,
|
||||
cursor.cmd,
|
||||
cursor.s,
|
||||
cursor.topology,
|
||||
cursor.options
|
||||
);
|
||||
|
||||
nextFunction(cursor, callback);
|
||||
} catch (err) {
|
||||
callback(err);
|
||||
return;
|
||||
}
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
function nextFunction(cursor, callback) {
|
||||
// We have notified about it
|
||||
if (cursor.s.notified) {
|
||||
return callback(new Error('cursor is exhausted'));
|
||||
}
|
||||
|
||||
// Cursor is killed return null
|
||||
if (isCursorKilled(cursor, callback)) return;
|
||||
|
||||
// Cursor is dead but not marked killed, return null
|
||||
if (isCursorDeadButNotkilled(cursor, callback)) return;
|
||||
|
||||
// We have a dead and killed cursor, attempting to call next should error
|
||||
if (isCursorDeadAndKilled(cursor, callback)) return;
|
||||
|
||||
// We have just started the cursor
|
||||
if (!cursor.s.init) {
|
||||
return initializeCursorAndRetryNext(cursor, callback);
|
||||
}
|
||||
|
||||
// If we don't have a cursorId execute the first query
|
||||
if (cursor.s.cursorId == null) {
|
||||
// Check if pool is dead and return if not possible to
|
||||
// execute the query against the db
|
||||
if (isConnectionDead(cursor, callback)) return;
|
||||
|
||||
// query, cmd, options, s, callback
|
||||
return _find(cursor, function(err) {
|
||||
if (err) return handleCallback(callback, err, null);
|
||||
|
||||
if (cursor.s.cursorId && cursor.s.cursorId.isZero() && cursor._endSession) {
|
||||
cursor._endSession();
|
||||
}
|
||||
|
||||
if (
|
||||
cursor.s.documents.length === 0 &&
|
||||
cursor.s.cursorId &&
|
||||
cursor.s.cursorId.isZero() &&
|
||||
!cursor.cmd.tailable &&
|
||||
!cursor.cmd.awaitData
|
||||
) {
|
||||
return setCursorNotified(cursor, callback);
|
||||
}
|
||||
|
||||
nextFunction(cursor, callback);
|
||||
});
|
||||
}
|
||||
|
||||
if (cursor.s.documents.length === cursor.s.cursorIndex && Long.ZERO.equals(cursor.s.cursorId)) {
|
||||
setCursorDeadAndNotified(cursor, callback);
|
||||
return;
|
||||
}
|
||||
|
||||
if (cursor.s.limit > 0 && cursor.s.currentLimit >= cursor.s.limit) {
|
||||
// Ensure we kill the cursor on the server
|
||||
cursor.kill();
|
||||
// Set cursor in dead and notified state
|
||||
setCursorDeadAndNotified(cursor, callback);
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
cursor.s.documents.length === cursor.s.cursorIndex &&
|
||||
cursor.cmd.tailable &&
|
||||
Long.ZERO.equals(cursor.s.cursorId)
|
||||
) {
|
||||
return handleCallback(
|
||||
callback,
|
||||
new MongoError({
|
||||
message: 'No more documents in tailed cursor',
|
||||
tailable: cursor.cmd.tailable,
|
||||
awaitData: cursor.cmd.awaitData
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
if (cursor.s.cursorIndex === cursor.s.documents.length && !Long.ZERO.equals(cursor.s.cursorId)) {
|
||||
// Ensure an empty cursor state
|
||||
cursor.s.documents = [];
|
||||
cursor.s.cursorIndex = 0;
|
||||
|
||||
// Check if connection is dead and return if not possible to
|
||||
if (isConnectionDead(cursor, callback)) return;
|
||||
|
||||
// Execute the next get more
|
||||
return _getmore(cursor, function(err, doc, connection) {
|
||||
if (err) {
|
||||
if (err instanceof MongoError) {
|
||||
err[mongoErrorContextSymbol].isGetMore = true;
|
||||
}
|
||||
|
||||
return handleCallback(callback, err);
|
||||
}
|
||||
|
||||
if (cursor.s.cursorId && cursor.s.cursorId.isZero() && cursor._endSession) {
|
||||
cursor._endSession();
|
||||
}
|
||||
|
||||
// Save the returned connection to ensure all getMore's fire over the same connection
|
||||
cursor.connection = connection;
|
||||
|
||||
// Tailable cursor getMore result, notify owner about it
|
||||
// No attempt is made here to retry, this is left to the user of the
|
||||
// core module to handle to keep core simple
|
||||
if (
|
||||
cursor.s.documents.length === 0 &&
|
||||
cursor.cmd.tailable &&
|
||||
Long.ZERO.equals(cursor.s.cursorId)
|
||||
) {
|
||||
// No more documents in the tailed cursor
|
||||
return handleCallback(
|
||||
callback,
|
||||
new MongoError({
|
||||
message: 'No more documents in tailed cursor',
|
||||
tailable: cursor.cmd.tailable,
|
||||
awaitData: cursor.cmd.awaitData
|
||||
})
|
||||
);
|
||||
} else if (
|
||||
cursor.s.documents.length === 0 &&
|
||||
cursor.cmd.tailable &&
|
||||
!Long.ZERO.equals(cursor.s.cursorId)
|
||||
) {
|
||||
return nextFunction(cursor, callback);
|
||||
}
|
||||
|
||||
if (cursor.s.limit > 0 && cursor.s.currentLimit >= cursor.s.limit) {
|
||||
return setCursorDeadAndNotified(cursor, callback);
|
||||
}
|
||||
|
||||
nextFunction(cursor, callback);
|
||||
});
|
||||
}
|
||||
|
||||
if (cursor.s.limit > 0 && cursor.s.currentLimit >= cursor.s.limit) {
|
||||
// Ensure we kill the cursor on the server
|
||||
cursor.kill();
|
||||
// Set cursor in dead and notified state
|
||||
return setCursorDeadAndNotified(cursor, callback);
|
||||
}
|
||||
|
||||
// Increment the current cursor limit
|
||||
cursor.s.currentLimit += 1;
|
||||
|
||||
// Get the document
|
||||
let doc = cursor.s.documents[cursor.s.cursorIndex++];
|
||||
|
||||
// Doc overflow
|
||||
if (!doc || doc.$err) {
|
||||
// Ensure we kill the cursor on the server
|
||||
cursor.kill();
|
||||
// Set cursor in dead and notified state
|
||||
return setCursorDeadAndNotified(cursor, function() {
|
||||
handleCallback(callback, new MongoError(doc ? doc.$err : undefined));
|
||||
});
|
||||
}
|
||||
|
||||
// Transform the doc with passed in transformation method if provided
|
||||
if (cursor.s.transforms && typeof cursor.s.transforms.doc === 'function') {
|
||||
doc = cursor.s.transforms.doc(doc);
|
||||
}
|
||||
|
||||
// Return the document
|
||||
handleCallback(callback, null, doc);
|
||||
}
|
||||
|
||||
module.exports = Cursor;
|
||||
+217
@@ -0,0 +1,217 @@
|
||||
'use strict';
|
||||
|
||||
const ServerDescription = require('./server_description').ServerDescription;
|
||||
const calculateDurationInMs = require('../utils').calculateDurationInMs;
|
||||
|
||||
/**
|
||||
* Published when server description changes, but does NOT include changes to the RTT.
|
||||
*
|
||||
* @property {Object} topologyId A unique identifier for the topology
|
||||
* @property {ServerAddress} address The address (host/port pair) of the server
|
||||
* @property {ServerDescription} previousDescription The previous server description
|
||||
* @property {ServerDescription} newDescription The new server description
|
||||
*/
|
||||
class ServerDescriptionChangedEvent {
|
||||
constructor(topologyId, address, previousDescription, newDescription) {
|
||||
Object.assign(this, { topologyId, address, previousDescription, newDescription });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Published when server is initialized.
|
||||
*
|
||||
* @property {Object} topologyId A unique identifier for the topology
|
||||
* @property {ServerAddress} address The address (host/port pair) of the server
|
||||
*/
|
||||
class ServerOpeningEvent {
|
||||
constructor(topologyId, address) {
|
||||
Object.assign(this, { topologyId, address });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Published when server is closed.
|
||||
*
|
||||
* @property {ServerAddress} address The address (host/port pair) of the server
|
||||
* @property {Object} topologyId A unique identifier for the topology
|
||||
*/
|
||||
class ServerClosedEvent {
|
||||
constructor(topologyId, address) {
|
||||
Object.assign(this, { topologyId, address });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Published when topology description changes.
|
||||
*
|
||||
* @property {Object} topologyId
|
||||
* @property {TopologyDescription} previousDescription The old topology description
|
||||
* @property {TopologyDescription} newDescription The new topology description
|
||||
*/
|
||||
class TopologyDescriptionChangedEvent {
|
||||
constructor(topologyId, previousDescription, newDescription) {
|
||||
Object.assign(this, { topologyId, previousDescription, newDescription });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Published when topology is initialized.
|
||||
*
|
||||
* @param {Object} topologyId A unique identifier for the topology
|
||||
*/
|
||||
class TopologyOpeningEvent {
|
||||
constructor(topologyId) {
|
||||
Object.assign(this, { topologyId });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Published when topology is closed.
|
||||
*
|
||||
* @param {Object} topologyId A unique identifier for the topology
|
||||
*/
|
||||
class TopologyClosedEvent {
|
||||
constructor(topologyId) {
|
||||
Object.assign(this, { topologyId });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when the server monitor’s ismaster command is started - immediately before
|
||||
* the ismaster command is serialized into raw BSON and written to the socket.
|
||||
*
|
||||
* @property {Object} connectionId The connection id for the command
|
||||
*/
|
||||
class ServerHeartbeatStartedEvent {
|
||||
constructor(connectionId) {
|
||||
Object.assign(this, { connectionId });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when the server monitor’s ismaster succeeds.
|
||||
*
|
||||
* @param {Number} duration The execution time of the event in ms
|
||||
* @param {Object} reply The command reply
|
||||
* @param {Object} connectionId The connection id for the command
|
||||
*/
|
||||
class ServerHeartbeatSucceededEvent {
|
||||
constructor(duration, reply, connectionId) {
|
||||
Object.assign(this, { duration, reply, connectionId });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Fired when the server monitor’s ismaster fails, either with an “ok: 0” or a socket exception.
|
||||
*
|
||||
* @param {Number} duration The execution time of the event in ms
|
||||
* @param {MongoError|Object} failure The command failure
|
||||
* @param {Object} connectionId The connection id for the command
|
||||
*/
|
||||
class ServerHeartbeatFailedEvent {
|
||||
constructor(duration, failure, connectionId) {
|
||||
Object.assign(this, { duration, failure, connectionId });
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Performs a server check as described by the SDAM spec.
|
||||
*
|
||||
* NOTE: This method automatically reschedules itself, so that there is always an active
|
||||
* monitoring process
|
||||
*
|
||||
* @param {Server} server The server to monitor
|
||||
*/
|
||||
function monitorServer(server) {
|
||||
// executes a single check of a server
|
||||
const checkServer = callback => {
|
||||
let start = process.hrtime();
|
||||
|
||||
// emit a signal indicating we have started the heartbeat
|
||||
server.emit('serverHeartbeatStarted', new ServerHeartbeatStartedEvent(server.name));
|
||||
|
||||
server.command(
|
||||
'admin.$cmd',
|
||||
{ ismaster: true },
|
||||
{
|
||||
monitoring: true,
|
||||
socketTimeout: server.s.options.connectionTimeout || 2000
|
||||
},
|
||||
function(err, result) {
|
||||
let duration = calculateDurationInMs(start);
|
||||
|
||||
if (err) {
|
||||
server.emit(
|
||||
'serverHeartbeatFailed',
|
||||
new ServerHeartbeatFailedEvent(duration, err, server.name)
|
||||
);
|
||||
|
||||
return callback(err, null);
|
||||
}
|
||||
|
||||
const isMaster = result.result;
|
||||
server.emit(
|
||||
'serverHeartbeatSucceded',
|
||||
new ServerHeartbeatSucceededEvent(duration, isMaster, server.name)
|
||||
);
|
||||
|
||||
return callback(null, isMaster);
|
||||
}
|
||||
);
|
||||
};
|
||||
|
||||
const successHandler = isMaster => {
|
||||
server.s.monitoring = false;
|
||||
|
||||
// emit an event indicating that our description has changed
|
||||
server.emit('descriptionReceived', new ServerDescription(server.description.address, isMaster));
|
||||
|
||||
// schedule the next monitoring process
|
||||
server.s.monitorId = setTimeout(
|
||||
() => monitorServer(server),
|
||||
server.s.options.heartbeatFrequencyMS
|
||||
);
|
||||
};
|
||||
|
||||
// run the actual monitoring loop
|
||||
server.s.monitoring = true;
|
||||
checkServer((err, isMaster) => {
|
||||
if (!err) {
|
||||
successHandler(isMaster);
|
||||
return;
|
||||
}
|
||||
|
||||
// According to the SDAM specification's "Network error during server check" section, if
|
||||
// an ismaster call fails we reset the server's pool. If a server was once connected,
|
||||
// change its type to `Unknown` only after retrying once.
|
||||
|
||||
// TODO: we need to reset the pool here
|
||||
|
||||
return checkServer((err, isMaster) => {
|
||||
if (err) {
|
||||
server.s.monitoring = false;
|
||||
|
||||
// revert to `Unknown` by emitting a default description with no isMaster
|
||||
server.emit('descriptionReceived', new ServerDescription(server.description.address));
|
||||
|
||||
// do not reschedule monitoring in this case
|
||||
return;
|
||||
}
|
||||
|
||||
successHandler(isMaster);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
ServerDescriptionChangedEvent,
|
||||
ServerOpeningEvent,
|
||||
ServerClosedEvent,
|
||||
TopologyDescriptionChangedEvent,
|
||||
TopologyOpeningEvent,
|
||||
TopologyClosedEvent,
|
||||
ServerHeartbeatStartedEvent,
|
||||
ServerHeartbeatSucceededEvent,
|
||||
ServerHeartbeatFailedEvent,
|
||||
monitorServer
|
||||
};
|
||||
+413
@@ -0,0 +1,413 @@
|
||||
'use strict';
|
||||
const EventEmitter = require('events');
|
||||
const MongoError = require('../error').MongoError;
|
||||
const Pool = require('../connection/pool');
|
||||
const relayEvents = require('../utils').relayEvents;
|
||||
const calculateDurationInMs = require('../utils').calculateDurationInMs;
|
||||
const Query = require('../connection/commands').Query;
|
||||
const TwoSixWireProtocolSupport = require('../wireprotocol/2_6_support');
|
||||
const ThreeTwoWireProtocolSupport = require('../wireprotocol/3_2_support');
|
||||
const BSON = require('../connection/utils').retrieveBSON();
|
||||
const createClientInfo = require('../topologies/shared').createClientInfo;
|
||||
const Logger = require('../connection/logger');
|
||||
const ServerDescription = require('./server_description').ServerDescription;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
const monitorServer = require('./monitoring').monitorServer;
|
||||
|
||||
/**
|
||||
*
|
||||
* @fires Server#serverHeartbeatStarted
|
||||
* @fires Server#serverHeartbeatSucceeded
|
||||
* @fires Server#serverHeartbeatFailed
|
||||
*/
|
||||
class Server extends EventEmitter {
|
||||
/**
|
||||
* Create a server
|
||||
*
|
||||
* @param {ServerDescription} description
|
||||
* @param {Object} options
|
||||
*/
|
||||
constructor(description, options) {
|
||||
super();
|
||||
|
||||
this.s = {
|
||||
// the server description
|
||||
description,
|
||||
// a saved copy of the incoming options
|
||||
options,
|
||||
// the server logger
|
||||
logger: Logger('Server', options),
|
||||
// the bson parser
|
||||
bson: options.bson || new BSON(),
|
||||
// client metadata for the initial handshake
|
||||
clientInfo: createClientInfo(options),
|
||||
// state variable to determine if there is an active server check in progress
|
||||
monitoring: false,
|
||||
// the connection pool
|
||||
pool: null
|
||||
};
|
||||
}
|
||||
|
||||
get description() {
|
||||
return this.s.description;
|
||||
}
|
||||
|
||||
get name() {
|
||||
return this.s.description.address;
|
||||
}
|
||||
|
||||
/**
|
||||
* Initiate server connect
|
||||
*
|
||||
* @param {Array} [options.auth] Array of auth options to apply on connect
|
||||
*/
|
||||
connect(options) {
|
||||
options = options || {};
|
||||
|
||||
// do not allow connect to be called on anything that's not disconnected
|
||||
if (this.s.pool && !this.s.pool.isDisconnected() && !this.s.pool.isDestroyed()) {
|
||||
throw new MongoError(`Server instance in invalid state ${this.s.pool.state}`);
|
||||
}
|
||||
|
||||
// create a pool
|
||||
this.s.pool = new Pool(this, Object.assign(this.s.options, options, { bson: this.s.bson }));
|
||||
|
||||
// Set up listeners
|
||||
this.s.pool.on('connect', connectEventHandler(this));
|
||||
this.s.pool.on('close', closeEventHandler(this));
|
||||
|
||||
// this.s.pool.on('error', errorEventHandler(this));
|
||||
// this.s.pool.on('timeout', timeoutEventHandler(this));
|
||||
// this.s.pool.on('parseError', errorEventHandler(this));
|
||||
// this.s.pool.on('reconnect', reconnectEventHandler(this));
|
||||
// this.s.pool.on('reconnectFailed', errorEventHandler(this));
|
||||
|
||||
// relay all command monitoring events
|
||||
relayEvents(this.s.pool, this, ['commandStarted', 'commandSucceeded', 'commandFailed']);
|
||||
|
||||
// If auth settings have been provided, use them
|
||||
if (options.auth) {
|
||||
this.s.pool.connect.apply(this.s.pool, options.auth);
|
||||
return;
|
||||
}
|
||||
|
||||
this.s.pool.connect();
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy the server connection
|
||||
*
|
||||
* @param {Boolean} [options.emitClose=false] Emit close event on destroy
|
||||
* @param {Boolean} [options.emitDestroy=false] Emit destroy event on destroy
|
||||
* @param {Boolean} [options.force=false] Force destroy the pool
|
||||
*/
|
||||
destroy(callback) {
|
||||
if (typeof callback === 'function') {
|
||||
callback(null, null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Immediately schedule monitoring of this server. If there already an attempt being made
|
||||
* this will be a no-op.
|
||||
*/
|
||||
monitor() {
|
||||
if (this.s.monitoring) return;
|
||||
if (this.s.monitorId) clearTimeout(this.s.monitorId);
|
||||
monitorServer(this);
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a command
|
||||
*
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {object} cmd The command hash
|
||||
* @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.checkKeys=false] Specify if the bson parser should validate keys.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {Boolean} [options.fullResult=false] Return the full envelope instead of just the result document.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
command(ns, cmd, options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
(callback = options), (options = {}), (options = options || {});
|
||||
}
|
||||
|
||||
const error = basicReadValidations(this, options);
|
||||
if (error) {
|
||||
return callback(error, null);
|
||||
}
|
||||
|
||||
// Clone the options
|
||||
options = Object.assign({}, options, { wireProtocolCommand: false });
|
||||
|
||||
// Debug log
|
||||
if (this.s.logger.isDebug()) {
|
||||
this.s.logger.debug(
|
||||
`executing command [${JSON.stringify({ ns, cmd, options })}] against ${this.name}`
|
||||
);
|
||||
}
|
||||
|
||||
// Check if we have collation support
|
||||
if (this.description.maxWireVersion < 5 && cmd.collation) {
|
||||
callback(new MongoError(`server ${this.name} does not support collation`));
|
||||
return;
|
||||
}
|
||||
|
||||
// Are we executing against a specific topology
|
||||
const topology = options.topology || {};
|
||||
// Create the query object
|
||||
const query = this.s.wireProtocolHandler.command(this.s.bson, ns, cmd, {}, topology, options);
|
||||
// Set slave OK of the query
|
||||
query.slaveOk = options.readPreference ? options.readPreference.slaveOk() : false;
|
||||
|
||||
// write options
|
||||
const writeOptions = {
|
||||
raw: typeof options.raw === 'boolean' ? options.raw : false,
|
||||
promoteLongs: typeof options.promoteLongs === 'boolean' ? options.promoteLongs : true,
|
||||
promoteValues: typeof options.promoteValues === 'boolean' ? options.promoteValues : true,
|
||||
promoteBuffers: typeof options.promoteBuffers === 'boolean' ? options.promoteBuffers : false,
|
||||
command: true,
|
||||
monitoring: typeof options.monitoring === 'boolean' ? options.monitoring : false,
|
||||
fullResult: typeof options.fullResult === 'boolean' ? options.fullResult : false,
|
||||
requestId: query.requestId,
|
||||
socketTimeout: typeof options.socketTimeout === 'number' ? options.socketTimeout : null,
|
||||
session: options.session || null
|
||||
};
|
||||
|
||||
// write the operation to the pool
|
||||
this.s.pool.write(query, writeOptions, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Insert one or more documents
|
||||
* @method
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {array} ops An array of documents to insert
|
||||
* @param {boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {object} [options.writeConcern={}] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
insert(ns, ops, options, callback) {
|
||||
executeWriteOperation({ server: this, op: 'insert', ns, ops }, options, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform one or more update operations
|
||||
* @method
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {array} ops An array of updates
|
||||
* @param {boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {object} [options.writeConcern={}] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
update(ns, ops, options, callback) {
|
||||
executeWriteOperation({ server: this, op: 'update', ns, ops }, options, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform one or more remove operations
|
||||
* @method
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {array} ops An array of removes
|
||||
* @param {boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {object} [options.writeConcern={}] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
remove(ns, ops, options, callback) {
|
||||
executeWriteOperation({ server: this, op: 'remove', ns, ops }, options, callback);
|
||||
}
|
||||
}
|
||||
|
||||
function basicWriteValidations(server) {
|
||||
if (!server.s.pool) {
|
||||
return new MongoError('server instance is not connected');
|
||||
}
|
||||
|
||||
if (server.s.pool.isDestroyed()) {
|
||||
return new MongoError('server instance pool was destroyed');
|
||||
}
|
||||
|
||||
return null;
|
||||
}
|
||||
|
||||
function basicReadValidations(server, options) {
|
||||
const error = basicWriteValidations(server, options);
|
||||
if (error) {
|
||||
return error;
|
||||
}
|
||||
|
||||
if (options.readPreference && !(options.readPreference instanceof ReadPreference)) {
|
||||
return new MongoError('readPreference must be an instance of ReadPreference');
|
||||
}
|
||||
}
|
||||
|
||||
function executeWriteOperation(args, options, callback) {
|
||||
if (typeof options === 'function') (callback = options), (options = {});
|
||||
options = options || {};
|
||||
|
||||
// TODO: once we drop Node 4, use destructuring either here or in arguments.
|
||||
const server = args.server;
|
||||
const op = args.op;
|
||||
const ns = args.ns;
|
||||
const ops = Array.isArray(args.ops) ? args.ops : [args.ops];
|
||||
|
||||
const error = basicWriteValidations(server, options);
|
||||
if (error) {
|
||||
callback(error, null);
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if we have collation support
|
||||
if (server.description.maxWireVersion < 5 && options.collation) {
|
||||
callback(new MongoError(`server ${this.name} does not support collation`));
|
||||
return;
|
||||
}
|
||||
|
||||
// Execute write
|
||||
return server.s.wireProtocolHandler[op](server.s.pool, ns, server.s.bson, ops, options, callback);
|
||||
}
|
||||
|
||||
function saslSupportedMechs(options) {
|
||||
if (!options) {
|
||||
return {};
|
||||
}
|
||||
|
||||
const authArray = options.auth || [];
|
||||
const authMechanism = authArray[0] || options.authMechanism;
|
||||
const authSource = authArray[1] || options.authSource || options.dbName || 'admin';
|
||||
const user = authArray[2] || options.user;
|
||||
|
||||
if (typeof authMechanism === 'string' && authMechanism.toUpperCase() !== 'DEFAULT') {
|
||||
return {};
|
||||
}
|
||||
|
||||
if (!user) {
|
||||
return {};
|
||||
}
|
||||
|
||||
return { saslSupportedMechs: `${authSource}.${user}` };
|
||||
}
|
||||
|
||||
function extractIsMasterError(err, result) {
|
||||
if (err) return err;
|
||||
if (result && result.result && result.result.ok === 0) {
|
||||
return new MongoError(result.result);
|
||||
}
|
||||
}
|
||||
|
||||
function executeServerHandshake(server, callback) {
|
||||
// construct an `ismaster` query
|
||||
const compressors =
|
||||
server.s.options.compression && server.s.options.compression.compressors
|
||||
? server.s.options.compression.compressors
|
||||
: [];
|
||||
|
||||
const queryOptions = { numberToSkip: 0, numberToReturn: -1, checkKeys: false, slaveOk: true };
|
||||
const query = new Query(
|
||||
server.s.bson,
|
||||
'admin.$cmd',
|
||||
Object.assign(
|
||||
{ ismaster: true, client: server.s.clientInfo, compression: compressors },
|
||||
saslSupportedMechs(server.s.options)
|
||||
),
|
||||
queryOptions
|
||||
);
|
||||
|
||||
// execute the query
|
||||
server.s.pool.write(
|
||||
query,
|
||||
{ socketTimeout: server.s.options.connectionTimeout || 2000 },
|
||||
callback
|
||||
);
|
||||
}
|
||||
|
||||
function configureWireProtocolHandler(ismaster) {
|
||||
// 3.2 wire protocol handler
|
||||
if (ismaster.maxWireVersion >= 4) {
|
||||
return new ThreeTwoWireProtocolSupport();
|
||||
}
|
||||
|
||||
// default to 2.6 wire protocol handler
|
||||
return new TwoSixWireProtocolSupport();
|
||||
}
|
||||
|
||||
function connectEventHandler(server) {
|
||||
return function() {
|
||||
// log information of received information if in info mode
|
||||
// if (server.s.logger.isInfo()) {
|
||||
// var object = err instanceof MongoError ? JSON.stringify(err) : {};
|
||||
// server.s.logger.info(`server ${server.name} fired event ${event} out with message ${object}`);
|
||||
// }
|
||||
|
||||
// begin initial server handshake
|
||||
const start = process.hrtime();
|
||||
executeServerHandshake(server, (err, response) => {
|
||||
// Set initial lastIsMasterMS - is this needed?
|
||||
server.s.lastIsMasterMS = calculateDurationInMs(start);
|
||||
|
||||
const serverError = extractIsMasterError(err, response);
|
||||
if (serverError) {
|
||||
server.emit('error', serverError);
|
||||
return;
|
||||
}
|
||||
|
||||
// extract the ismaster from the server response
|
||||
const isMaster = response.result;
|
||||
|
||||
// compression negotation
|
||||
if (isMaster && isMaster.compression) {
|
||||
const localCompressionInfo = server.s.options.compression;
|
||||
const localCompressors = localCompressionInfo.compressors;
|
||||
for (var i = 0; i < localCompressors.length; i++) {
|
||||
if (isMaster.compression.indexOf(localCompressors[i]) > -1) {
|
||||
server.s.pool.options.agreedCompressor = localCompressors[i];
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (localCompressionInfo.zlibCompressionLevel) {
|
||||
server.s.pool.options.zlibCompressionLevel = localCompressionInfo.zlibCompressionLevel;
|
||||
}
|
||||
}
|
||||
|
||||
// configure the wire protocol handler
|
||||
server.s.wireProtocolHandler = configureWireProtocolHandler(isMaster);
|
||||
|
||||
// log the connection event if requested
|
||||
if (server.s.logger.isInfo()) {
|
||||
server.s.logger.info(
|
||||
`server ${server.name} connected with ismaster [${JSON.stringify(isMaster)}]`
|
||||
);
|
||||
}
|
||||
|
||||
// emit an event indicating that our description has changed
|
||||
server.emit(
|
||||
'descriptionReceived',
|
||||
new ServerDescription(server.description.address, isMaster)
|
||||
);
|
||||
|
||||
// emit a connect event
|
||||
server.emit('connect', isMaster);
|
||||
});
|
||||
};
|
||||
}
|
||||
|
||||
function closeEventHandler(server) {
|
||||
return function() {
|
||||
server.emit('close');
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = Server;
|
||||
+141
@@ -0,0 +1,141 @@
|
||||
'use strict';
|
||||
|
||||
// An enumeration of server types we know about
|
||||
const ServerType = {
|
||||
Standalone: 'Standalone',
|
||||
Mongos: 'Mongos',
|
||||
PossiblePrimary: 'PossiblePrimary',
|
||||
RSPrimary: 'RSPrimary',
|
||||
RSSecondary: 'RSSecondary',
|
||||
RSArbiter: 'RSArbiter',
|
||||
RSOther: 'RSOther',
|
||||
RSGhost: 'RSGhost',
|
||||
Unknown: 'Unknown'
|
||||
};
|
||||
|
||||
const WRITABLE_SERVER_TYPES = new Set([
|
||||
ServerType.RSPrimary,
|
||||
ServerType.Standalone,
|
||||
ServerType.Mongos
|
||||
]);
|
||||
|
||||
const ISMASTER_FIELDS = [
|
||||
'minWireVersion',
|
||||
'maxWireVersion',
|
||||
'me',
|
||||
'hosts',
|
||||
'passives',
|
||||
'arbiters',
|
||||
'tags',
|
||||
'setName',
|
||||
'setVersion',
|
||||
'electionId',
|
||||
'primary',
|
||||
'logicalSessionTimeoutMinutes'
|
||||
];
|
||||
|
||||
/**
|
||||
* The client's view of a single server, based on the most recent ismaster outcome.
|
||||
*
|
||||
* Internal type, not meant to be directly instantiated
|
||||
*/
|
||||
class ServerDescription {
|
||||
/**
|
||||
* Create a ServerDescription
|
||||
* @param {String} address The address of the server
|
||||
* @param {Object} [ismaster] An optional ismaster response for this server
|
||||
* @param {Object} [options] Optional settings
|
||||
* @param {Number} [options.roundTripTime] The round trip time to ping this server (in ms)
|
||||
*/
|
||||
constructor(address, ismaster, options) {
|
||||
options = options || {};
|
||||
ismaster = Object.assign(
|
||||
{
|
||||
minWireVersion: 0,
|
||||
maxWireVersion: 0,
|
||||
hosts: [],
|
||||
passives: [],
|
||||
arbiters: [],
|
||||
tags: []
|
||||
},
|
||||
ismaster
|
||||
);
|
||||
|
||||
this.address = address;
|
||||
this.error = null;
|
||||
this.roundTripTime = options.roundTripTime || 0;
|
||||
this.lastUpdateTime = Date.now();
|
||||
this.lastWriteDate = ismaster.lastWrite ? ismaster.lastWrite.lastWriteDate : null;
|
||||
this.opTime = ismaster.lastWrite ? ismaster.lastWrite.opTime : null;
|
||||
this.type = parseServerType(ismaster);
|
||||
|
||||
// direct mappings
|
||||
ISMASTER_FIELDS.forEach(field => {
|
||||
if (typeof ismaster[field] !== 'undefined') this[field] = ismaster[field];
|
||||
});
|
||||
|
||||
// normalize case for hosts
|
||||
this.hosts = this.hosts.map(host => host.toLowerCase());
|
||||
this.passives = this.passives.map(host => host.toLowerCase());
|
||||
this.arbiters = this.arbiters.map(host => host.toLowerCase());
|
||||
}
|
||||
|
||||
get allHosts() {
|
||||
return this.hosts.concat(this.arbiters).concat(this.passives);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {Boolean} Is this server available for reads
|
||||
*/
|
||||
get isReadable() {
|
||||
return this.type === ServerType.RSSecondary || this.isWritable;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return {Boolean} Is this server available for writes
|
||||
*/
|
||||
get isWritable() {
|
||||
return WRITABLE_SERVER_TYPES.has(this.type);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses an `ismaster` message and determines the server type
|
||||
*
|
||||
* @param {Object} ismaster The `ismaster` message to parse
|
||||
* @return {ServerType}
|
||||
*/
|
||||
function parseServerType(ismaster) {
|
||||
if (!ismaster || !ismaster.ok) {
|
||||
return ServerType.Unknown;
|
||||
}
|
||||
|
||||
if (ismaster.isreplicaset) {
|
||||
return ServerType.RSGhost;
|
||||
}
|
||||
|
||||
if (ismaster.msg && ismaster.msg === 'isdbgrid') {
|
||||
return ServerType.Mongos;
|
||||
}
|
||||
|
||||
if (ismaster.setName) {
|
||||
if (ismaster.hidden) {
|
||||
return ServerType.RSOther;
|
||||
} else if (ismaster.ismaster) {
|
||||
return ServerType.RSPrimary;
|
||||
} else if (ismaster.secondary) {
|
||||
return ServerType.RSSecondary;
|
||||
} else if (ismaster.arbiterOnly) {
|
||||
return ServerType.RSArbiter;
|
||||
} else {
|
||||
return ServerType.RSOther;
|
||||
}
|
||||
}
|
||||
|
||||
return ServerType.Standalone;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
ServerDescription,
|
||||
ServerType
|
||||
};
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
'use strict';
|
||||
const ServerType = require('./server_description').ServerType;
|
||||
const TopologyType = require('./topology_description').TopologyType;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
const MongoError = require('../error').MongoError;
|
||||
|
||||
// max staleness constants
|
||||
const IDLE_WRITE_PERIOD = 10000;
|
||||
const SMALLEST_MAX_STALENESS_SECONDS = 90;
|
||||
|
||||
function writableServerSelector() {
|
||||
return function(topologyDescription, servers) {
|
||||
return latencyWindowReducer(topologyDescription, servers.filter(s => s.isWritable));
|
||||
};
|
||||
}
|
||||
|
||||
// reducers
|
||||
function maxStalenessReducer(readPreference, topologyDescription, servers) {
|
||||
if (readPreference.maxStalenessSeconds == null || readPreference.maxStalenessSeconds < 0) {
|
||||
return servers;
|
||||
}
|
||||
|
||||
const maxStaleness = readPreference.maxStalenessSeconds;
|
||||
const maxStalenessVariance =
|
||||
(topologyDescription.heartbeatFrequencyMS + IDLE_WRITE_PERIOD) / 1000;
|
||||
if (maxStaleness < maxStalenessVariance) {
|
||||
throw MongoError(`maxStalenessSeconds must be at least ${maxStalenessVariance} seconds`);
|
||||
}
|
||||
|
||||
if (maxStaleness < SMALLEST_MAX_STALENESS_SECONDS) {
|
||||
throw new MongoError(
|
||||
`maxStalenessSeconds must be at least ${SMALLEST_MAX_STALENESS_SECONDS} seconds`
|
||||
);
|
||||
}
|
||||
|
||||
if (topologyDescription.type === TopologyType.ReplicaSetWithPrimary) {
|
||||
const primary = servers.filter(primaryFilter)[0];
|
||||
return servers.reduce((result, server) => {
|
||||
const stalenessMS =
|
||||
server.lastUpdateTime -
|
||||
server.lastWriteDate -
|
||||
(primary.lastUpdateTime - primary.lastWriteDate) +
|
||||
topologyDescription.heartbeatFrequencyMS;
|
||||
|
||||
const staleness = stalenessMS / 1000;
|
||||
if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
|
||||
return result;
|
||||
}, []);
|
||||
} else if (topologyDescription.type === TopologyType.ReplicaSetNoPrimary) {
|
||||
const sMax = servers.reduce((max, s) => (s.lastWriteDate > max.lastWriteDate ? s : max));
|
||||
return servers.reduce((result, server) => {
|
||||
const stalenessMS =
|
||||
sMax.lastWriteDate - server.lastWriteDate + topologyDescription.heartbeatFrequencyMS;
|
||||
|
||||
const staleness = stalenessMS / 1000;
|
||||
if (staleness <= readPreference.maxStalenessSeconds) result.push(server);
|
||||
return result;
|
||||
}, []);
|
||||
}
|
||||
|
||||
return servers;
|
||||
}
|
||||
|
||||
function tagSetMatch(tagSet, serverTags) {
|
||||
const keys = Object.keys(tagSet);
|
||||
const serverTagKeys = Object.keys(serverTags);
|
||||
for (let i = 0; i < keys.length; ++i) {
|
||||
const key = keys[i];
|
||||
if (serverTagKeys.indexOf(key) === -1 || serverTags[key] !== tagSet[key]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
function tagSetReducer(readPreference, servers) {
|
||||
if (
|
||||
readPreference.tags == null ||
|
||||
(Array.isArray(readPreference.tags) && readPreference.tags.length === 0)
|
||||
) {
|
||||
return servers;
|
||||
}
|
||||
|
||||
for (let i = 0; i < readPreference.tags.length; ++i) {
|
||||
const tagSet = readPreference.tags[i];
|
||||
const serversMatchingTagset = servers.reduce((matched, server) => {
|
||||
if (tagSetMatch(tagSet, server.tags)) matched.push(server);
|
||||
return matched;
|
||||
}, []);
|
||||
|
||||
if (serversMatchingTagset.length) {
|
||||
return serversMatchingTagset;
|
||||
}
|
||||
}
|
||||
|
||||
return [];
|
||||
}
|
||||
|
||||
function latencyWindowReducer(topologyDescription, servers) {
|
||||
const low = servers.reduce(
|
||||
(min, server) => (min === -1 ? server.roundTripTime : Math.min(server.roundTripTime, min)),
|
||||
-1
|
||||
);
|
||||
|
||||
const high = low + topologyDescription.localThresholdMS;
|
||||
|
||||
return servers.reduce((result, server) => {
|
||||
if (server.roundTripTime <= high && server.roundTripTime >= low) result.push(server);
|
||||
return result;
|
||||
}, []);
|
||||
}
|
||||
|
||||
// filters
|
||||
function primaryFilter(server) {
|
||||
return server.type === ServerType.RSPrimary;
|
||||
}
|
||||
|
||||
function secondaryFilter(server) {
|
||||
return server.type === ServerType.RSSecondary;
|
||||
}
|
||||
|
||||
function nearestFilter(server) {
|
||||
return server.type === ServerType.RSSecondary || server.type === ServerType.RSPrimary;
|
||||
}
|
||||
|
||||
function knownFilter(server) {
|
||||
return server.type !== ServerType.Unknown;
|
||||
}
|
||||
|
||||
function readPreferenceServerSelector(readPreference) {
|
||||
if (!readPreference.isValid()) {
|
||||
throw new TypeError('Invalid read preference specified');
|
||||
}
|
||||
|
||||
return function(topologyDescription, servers) {
|
||||
const commonWireVersion = topologyDescription.commonWireVersion;
|
||||
if (
|
||||
commonWireVersion &&
|
||||
(readPreference.minWireVersion && readPreference.minWireVersion > commonWireVersion)
|
||||
) {
|
||||
throw new MongoError(
|
||||
`Minimum wire version '${
|
||||
readPreference.minWireVersion
|
||||
}' required, but found '${commonWireVersion}'`
|
||||
);
|
||||
}
|
||||
|
||||
if (
|
||||
topologyDescription.type === TopologyType.Single ||
|
||||
topologyDescription.type === TopologyType.Sharded
|
||||
) {
|
||||
return latencyWindowReducer(topologyDescription, servers.filter(knownFilter));
|
||||
}
|
||||
|
||||
if (readPreference.mode === ReadPreference.PRIMARY) {
|
||||
return servers.filter(primaryFilter);
|
||||
}
|
||||
|
||||
if (readPreference.mode === ReadPreference.SECONDARY) {
|
||||
return latencyWindowReducer(
|
||||
topologyDescription,
|
||||
tagSetReducer(
|
||||
readPreference,
|
||||
maxStalenessReducer(readPreference, topologyDescription, servers)
|
||||
)
|
||||
).filter(secondaryFilter);
|
||||
} else if (readPreference.mode === ReadPreference.NEAREST) {
|
||||
return latencyWindowReducer(
|
||||
topologyDescription,
|
||||
tagSetReducer(
|
||||
readPreference,
|
||||
maxStalenessReducer(readPreference, topologyDescription, servers)
|
||||
)
|
||||
).filter(nearestFilter);
|
||||
} else if (readPreference.mode === ReadPreference.SECONDARY_PREFERRED) {
|
||||
const result = latencyWindowReducer(
|
||||
topologyDescription,
|
||||
tagSetReducer(
|
||||
readPreference,
|
||||
maxStalenessReducer(readPreference, topologyDescription, servers)
|
||||
)
|
||||
).filter(secondaryFilter);
|
||||
|
||||
return result.length === 0 ? servers.filter(primaryFilter) : result;
|
||||
} else if (readPreference.mode === ReadPreference.PRIMARY_PREFERRED) {
|
||||
const result = servers.filter(primaryFilter);
|
||||
if (result.length) {
|
||||
return result;
|
||||
}
|
||||
|
||||
return latencyWindowReducer(
|
||||
topologyDescription,
|
||||
tagSetReducer(
|
||||
readPreference,
|
||||
maxStalenessReducer(readPreference, topologyDescription, servers)
|
||||
)
|
||||
).filter(secondaryFilter);
|
||||
}
|
||||
};
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
writableServerSelector,
|
||||
readPreferenceServerSelector
|
||||
};
|
||||
+666
@@ -0,0 +1,666 @@
|
||||
'use strict';
|
||||
const EventEmitter = require('events');
|
||||
const ServerDescription = require('./server_description').ServerDescription;
|
||||
const TopologyDescription = require('./topology_description').TopologyDescription;
|
||||
const TopologyType = require('./topology_description').TopologyType;
|
||||
const monitoring = require('./monitoring');
|
||||
const calculateDurationInMs = require('../utils').calculateDurationInMs;
|
||||
const MongoTimeoutError = require('../error').MongoTimeoutError;
|
||||
const MongoNetworkError = require('../error').MongoNetworkError;
|
||||
const Server = require('./server');
|
||||
const relayEvents = require('../utils').relayEvents;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
const readPreferenceServerSelector = require('./server_selectors').readPreferenceServerSelector;
|
||||
const writableServerSelector = require('./server_selectors').writableServerSelector;
|
||||
const isRetryableWritesSupported = require('../topologies/shared').isRetryableWritesSupported;
|
||||
const Cursor = require('./cursor');
|
||||
const deprecate = require('util').deprecate;
|
||||
const BSON = require('../connection/utils').retrieveBSON();
|
||||
const createCompressionInfo = require('../topologies/shared').createCompressionInfo;
|
||||
|
||||
// Global state
|
||||
let globalTopologyCounter = 0;
|
||||
|
||||
// Constants
|
||||
const TOPOLOGY_DEFAULTS = {
|
||||
localThresholdMS: 15,
|
||||
serverSelectionTimeoutMS: 10000,
|
||||
heartbeatFrequencyMS: 30000,
|
||||
minHeartbeatIntervalMS: 500
|
||||
};
|
||||
|
||||
/**
|
||||
* A container of server instances representing a connection to a MongoDB topology.
|
||||
*
|
||||
* @fires Topology#serverOpening
|
||||
* @fires Topology#serverClosed
|
||||
* @fires Topology#serverDescriptionChanged
|
||||
* @fires Topology#topologyOpening
|
||||
* @fires Topology#topologyClosed
|
||||
* @fires Topology#topologyDescriptionChanged
|
||||
* @fires Topology#serverHeartbeatStarted
|
||||
* @fires Topology#serverHeartbeatSucceeded
|
||||
* @fires Topology#serverHeartbeatFailed
|
||||
*/
|
||||
class Topology extends EventEmitter {
|
||||
/**
|
||||
* Create a topology
|
||||
*
|
||||
* @param {Array|String} [seedlist] a string list, or array of Server instances to connect to
|
||||
* @param {Object} [options] Optional settings
|
||||
* @param {Number} [options.localThresholdMS=15] The size of the latency window for selecting among multiple suitable servers
|
||||
* @param {Number} [options.serverSelectionTimeoutMS=30000] How long to block for server selection before throwing an error
|
||||
* @param {Number} [options.heartbeatFrequencyMS=10000] The frequency with which topology updates are scheduled
|
||||
*/
|
||||
constructor(seedlist, options) {
|
||||
super();
|
||||
if (typeof options === 'undefined') {
|
||||
options = seedlist;
|
||||
seedlist = [];
|
||||
|
||||
// this is for legacy single server constructor support
|
||||
if (options.host) {
|
||||
seedlist.push({ host: options.host, port: options.port });
|
||||
}
|
||||
}
|
||||
|
||||
seedlist = seedlist || [];
|
||||
options = Object.assign({}, TOPOLOGY_DEFAULTS, options);
|
||||
|
||||
const topologyType = topologyTypeFromSeedlist(seedlist, options);
|
||||
const topologyId = globalTopologyCounter++;
|
||||
const serverDescriptions = seedlist.reduce((result, seed) => {
|
||||
const address = seed.port ? `${seed.host}:${seed.port}` : `${seed.host}:27017`;
|
||||
result.set(address, new ServerDescription(address));
|
||||
return result;
|
||||
}, new Map());
|
||||
|
||||
this.s = {
|
||||
// the id of this topology
|
||||
id: topologyId,
|
||||
// passed in options
|
||||
options: Object.assign({}, options),
|
||||
// initial seedlist of servers to connect to
|
||||
seedlist: seedlist,
|
||||
// the topology description
|
||||
description: new TopologyDescription(
|
||||
topologyType,
|
||||
serverDescriptions,
|
||||
options.replicaset,
|
||||
null,
|
||||
null,
|
||||
options
|
||||
),
|
||||
serverSelectionTimeoutMS: options.serverSelectionTimeoutMS,
|
||||
heartbeatFrequencyMS: options.heartbeatFrequencyMS,
|
||||
minHeartbeatIntervalMS: options.minHeartbeatIntervalMS,
|
||||
// allow users to override the cursor factory
|
||||
Cursor: options.cursorFactory || Cursor,
|
||||
// the bson parser
|
||||
bson:
|
||||
options.bson ||
|
||||
new BSON([
|
||||
BSON.Binary,
|
||||
BSON.Code,
|
||||
BSON.DBRef,
|
||||
BSON.Decimal128,
|
||||
BSON.Double,
|
||||
BSON.Int32,
|
||||
BSON.Long,
|
||||
BSON.Map,
|
||||
BSON.MaxKey,
|
||||
BSON.MinKey,
|
||||
BSON.ObjectId,
|
||||
BSON.BSONRegExp,
|
||||
BSON.Symbol,
|
||||
BSON.Timestamp
|
||||
])
|
||||
};
|
||||
|
||||
// amend options for server instance creation
|
||||
this.s.options.compression = { compressors: createCompressionInfo(options) };
|
||||
}
|
||||
|
||||
/**
|
||||
* @return A `TopologyDescription` for this topology
|
||||
*/
|
||||
get description() {
|
||||
return this.s.description;
|
||||
}
|
||||
|
||||
/**
|
||||
* All raw connections
|
||||
* @method
|
||||
* @return {Connection[]}
|
||||
*/
|
||||
connections() {
|
||||
return Array.from(this.s.servers.values()).reduce((result, server) => {
|
||||
return result.concat(server.s.pool.allConnections());
|
||||
}, []);
|
||||
}
|
||||
|
||||
/**
|
||||
* Initiate server connect
|
||||
*
|
||||
* @param {Object} [options] Optional settings
|
||||
* @param {Array} [options.auth=null] Array of auth options to apply on connect
|
||||
*/
|
||||
connect(/* options */) {
|
||||
// emit SDAM monitoring events
|
||||
this.emit('topologyOpening', new monitoring.TopologyOpeningEvent(this.s.id));
|
||||
|
||||
// emit an event for the topology change
|
||||
this.emit(
|
||||
'topologyDescriptionChanged',
|
||||
new monitoring.TopologyDescriptionChangedEvent(
|
||||
this.s.id,
|
||||
new TopologyDescription(TopologyType.Unknown), // initial is always Unknown
|
||||
this.s.description
|
||||
)
|
||||
);
|
||||
|
||||
connectServers(this, Array.from(this.s.description.servers.values()));
|
||||
this.s.connected = true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Close this topology
|
||||
*/
|
||||
close(callback) {
|
||||
// destroy all child servers
|
||||
this.s.servers.forEach(server => server.destroy());
|
||||
|
||||
// emit an event for close
|
||||
this.emit('topologyClosed', new monitoring.TopologyClosedEvent(this.s.id));
|
||||
|
||||
this.s.connected = false;
|
||||
|
||||
if (typeof callback === 'function') {
|
||||
callback(null, null);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects a server according to the selection predicate provided
|
||||
*
|
||||
* @param {function} [selector] An optional selector to select servers by, defaults to a random selection within a latency window
|
||||
* @return {Server} An instance of a `Server` meeting the criteria of the predicate provided
|
||||
*/
|
||||
selectServer(selector, options, callback) {
|
||||
if (typeof options === 'function') (callback = options), (options = {});
|
||||
options = Object.assign(
|
||||
{},
|
||||
{ serverSelectionTimeoutMS: this.s.serverSelectionTimeoutMS },
|
||||
options
|
||||
);
|
||||
|
||||
selectServers(
|
||||
this,
|
||||
selector,
|
||||
options.serverSelectionTimeoutMS,
|
||||
process.hrtime(),
|
||||
(err, servers) => {
|
||||
if (err) return callback(err, null);
|
||||
callback(null, randomSelection(servers));
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Update the internal TopologyDescription with a ServerDescription
|
||||
*
|
||||
* @param {object} serverDescription The server to update in the internal list of server descriptions
|
||||
*/
|
||||
serverUpdateHandler(serverDescription) {
|
||||
if (!this.s.description.hasServer(serverDescription.address)) {
|
||||
return;
|
||||
}
|
||||
|
||||
// these will be used for monitoring events later
|
||||
const previousTopologyDescription = this.s.description;
|
||||
const previousServerDescription = this.s.description.servers.get(serverDescription.address);
|
||||
|
||||
// first update the TopologyDescription
|
||||
this.s.description = this.s.description.update(serverDescription);
|
||||
|
||||
// emit monitoring events for this change
|
||||
this.emit(
|
||||
'serverDescriptionChanged',
|
||||
new monitoring.ServerDescriptionChangedEvent(
|
||||
this.s.id,
|
||||
serverDescription.address,
|
||||
previousServerDescription,
|
||||
this.s.description.servers.get(serverDescription.address)
|
||||
)
|
||||
);
|
||||
|
||||
// update server list from updated descriptions
|
||||
updateServers(this, serverDescription);
|
||||
|
||||
this.emit(
|
||||
'topologyDescriptionChanged',
|
||||
new monitoring.TopologyDescriptionChangedEvent(
|
||||
this.s.id,
|
||||
previousTopologyDescription,
|
||||
this.s.description
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Authenticate using a specified mechanism
|
||||
*
|
||||
* @param {String} mechanism The auth mechanism used for authentication
|
||||
* @param {String} db The db we are authenticating against
|
||||
* @param {Object} options Optional settings for the authenticating mechanism
|
||||
* @param {authResultCallback} callback A callback function
|
||||
*/
|
||||
auth(mechanism, db, options, callback) {
|
||||
callback(null, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Logout from a database
|
||||
*
|
||||
* @param {String} db The db we are logging out from
|
||||
* @param {authResultCallback} callback A callback function
|
||||
*/
|
||||
logout(db, callback) {
|
||||
callback(null, null);
|
||||
}
|
||||
|
||||
// Basic operation support. Eventually this should be moved into command construction
|
||||
// during the command refactor.
|
||||
|
||||
/**
|
||||
* Insert one or more documents
|
||||
*
|
||||
* @param {String} ns The full qualified namespace for this operation
|
||||
* @param {Array} ops An array of documents to insert
|
||||
* @param {Boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {Object} [options.writeConcern] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields
|
||||
* @param {ClientSession} [options.session] Session to use for the operation
|
||||
* @param {boolean} [options.retryWrites] Enable retryable writes for this operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
insert(ns, ops, options, callback) {
|
||||
executeWriteOperation({ topology: this, op: 'insert', ns, ops }, options, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform one or more update operations
|
||||
*
|
||||
* @param {string} ns The fully qualified namespace for this operation
|
||||
* @param {array} ops An array of updates
|
||||
* @param {boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {object} [options.writeConcern] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields
|
||||
* @param {ClientSession} [options.session] Session to use for the operation
|
||||
* @param {boolean} [options.retryWrites] Enable retryable writes for this operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
update(ns, ops, options, callback) {
|
||||
executeWriteOperation({ topology: this, op: 'update', ns, ops }, options, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Perform one or more remove operations
|
||||
*
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {array} ops An array of removes
|
||||
* @param {boolean} [options.ordered=true] Execute in order or out of order
|
||||
* @param {object} [options.writeConcern={}] Write concern for the operation
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {boolean} [options.retryWrites] Enable retryable writes for this operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
remove(ns, ops, options, callback) {
|
||||
executeWriteOperation({ topology: this, op: 'remove', ns, ops }, options, callback);
|
||||
}
|
||||
|
||||
/**
|
||||
* Execute a command
|
||||
*
|
||||
* @method
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {object} cmd The command hash
|
||||
* @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
|
||||
* @param {Connection} [options.connection] Specify connection object to execute command against
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {opResultCallback} callback A callback function
|
||||
*/
|
||||
command(ns, cmd, options, callback) {
|
||||
if (typeof options === 'function') {
|
||||
(callback = options), (options = {}), (options = options || {});
|
||||
}
|
||||
|
||||
const readPreference = options.readPreference ? options.readPreference : ReadPreference.primary;
|
||||
this.selectServer(readPreferenceServerSelector(readPreference), (err, server) => {
|
||||
if (err) {
|
||||
callback(err, null);
|
||||
return;
|
||||
}
|
||||
|
||||
server.command(ns, cmd, options, callback);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new cursor
|
||||
*
|
||||
* @method
|
||||
* @param {string} ns The MongoDB fully qualified namespace (ex: db1.collection1)
|
||||
* @param {object|Long} cmd Can be either a command returning a cursor or a cursorId
|
||||
* @param {object} [options] Options for the cursor
|
||||
* @param {object} [options.batchSize=0] Batchsize for the operation
|
||||
* @param {array} [options.documents=[]] Initial documents list for cursor
|
||||
* @param {ReadPreference} [options.readPreference] Specify read preference if command supports it
|
||||
* @param {Boolean} [options.serializeFunctions=false] Specify if functions on an object should be serialized.
|
||||
* @param {Boolean} [options.ignoreUndefined=false] Specify if the BSON serializer should ignore undefined fields.
|
||||
* @param {ClientSession} [options.session=null] Session to use for the operation
|
||||
* @param {object} [options.topology] The internal topology of the created cursor
|
||||
* @returns {Cursor}
|
||||
*/
|
||||
cursor(ns, cmd, options) {
|
||||
options = options || {};
|
||||
const topology = options.topology || this;
|
||||
const CursorClass = options.cursorFactory || this.s.Cursor;
|
||||
|
||||
return new CursorClass(this.s.bson, ns, cmd, options, topology, this.s.options);
|
||||
}
|
||||
}
|
||||
|
||||
// legacy aliases
|
||||
Topology.prototype.destroy = deprecate(
|
||||
Topology.prototype.close,
|
||||
'destroy() is deprecated, please use close() instead'
|
||||
);
|
||||
|
||||
function topologyTypeFromSeedlist(seedlist, options) {
|
||||
if (seedlist.length === 1 && !options.replicaset) return TopologyType.Single;
|
||||
if (options.replicaset) return TopologyType.ReplicaSetNoPrimary;
|
||||
return TopologyType.Unknown;
|
||||
}
|
||||
|
||||
function randomSelection(array) {
|
||||
return array[Math.floor(Math.random() * array.length)];
|
||||
}
|
||||
|
||||
/**
|
||||
* Selects servers using the provided selector
|
||||
*
|
||||
* @private
|
||||
* @param {Topology} topology The topology to select servers from
|
||||
* @param {function} selector The actual predicate used for selecting servers
|
||||
* @param {Number} timeout The max time we are willing wait for selection
|
||||
* @param {Number} start A high precision timestamp for the start of the selection process
|
||||
* @param {function} callback The callback used to convey errors or the resultant servers
|
||||
*/
|
||||
function selectServers(topology, selector, timeout, start, callback) {
|
||||
const serverDescriptions = Array.from(topology.description.servers.values());
|
||||
let descriptions;
|
||||
|
||||
try {
|
||||
descriptions = selector
|
||||
? selector(topology.description, serverDescriptions)
|
||||
: serverDescriptions;
|
||||
} catch (e) {
|
||||
return callback(e, null);
|
||||
}
|
||||
|
||||
if (descriptions.length) {
|
||||
const servers = descriptions.map(description => topology.s.servers.get(description.address));
|
||||
return callback(null, servers);
|
||||
}
|
||||
|
||||
const duration = calculateDurationInMs(start);
|
||||
if (duration >= timeout) {
|
||||
return callback(new MongoTimeoutError(`Server selection timed out after ${timeout} ms`));
|
||||
}
|
||||
|
||||
const retrySelection = () => {
|
||||
// ensure all server monitors attempt monitoring immediately
|
||||
topology.s.servers.forEach(server => server.monitor());
|
||||
|
||||
const iterationTimer = setTimeout(() => {
|
||||
callback(new MongoTimeoutError('Server selection timed out due to monitoring'));
|
||||
}, topology.s.minHeartbeatIntervalMS);
|
||||
|
||||
topology.once('topologyDescriptionChanged', () => {
|
||||
// successful iteration, clear the check timer
|
||||
clearTimeout(iterationTimer);
|
||||
|
||||
// topology description has changed due to monitoring, reattempt server selection
|
||||
selectServers(topology, selector, timeout, start, callback);
|
||||
});
|
||||
};
|
||||
|
||||
// ensure we are connected
|
||||
if (!topology.s.connected) {
|
||||
topology.connect();
|
||||
|
||||
// we want to make sure we're still within the requested timeout window
|
||||
const failToConnectTimer = setTimeout(() => {
|
||||
callback(new MongoTimeoutError('Server selection timed out waiting to connect'));
|
||||
}, timeout - duration);
|
||||
|
||||
topology.once('connect', () => {
|
||||
clearTimeout(failToConnectTimer);
|
||||
retrySelection();
|
||||
});
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
retrySelection();
|
||||
}
|
||||
|
||||
/**
|
||||
* Create `Server` instances for all initially known servers, connect them, and assign
|
||||
* them to the passed in `Topology`.
|
||||
*
|
||||
* @param {Topology} topology The topology responsible for the servers
|
||||
* @param {ServerDescription[]} serverDescriptions A list of server descriptions to connect
|
||||
*/
|
||||
function connectServers(topology, serverDescriptions) {
|
||||
topology.s.servers = serverDescriptions.reduce((servers, serverDescription) => {
|
||||
// publish an open event for each ServerDescription created
|
||||
topology.emit(
|
||||
'serverOpening',
|
||||
new monitoring.ServerOpeningEvent(topology.s.id, serverDescription.address)
|
||||
);
|
||||
|
||||
const server = new Server(serverDescription, topology.s.options);
|
||||
relayEvents(server, topology, [
|
||||
'serverHeartbeatStarted',
|
||||
'serverHeartbeatSucceeded',
|
||||
'serverHeartbeatFailed'
|
||||
]);
|
||||
|
||||
server.on('descriptionReceived', topology.serverUpdateHandler.bind(topology));
|
||||
server.on('connect', serverConnectEventHandler(server, topology));
|
||||
servers.set(serverDescription.address, server);
|
||||
server.connect();
|
||||
return servers;
|
||||
}, new Map());
|
||||
}
|
||||
|
||||
function updateServers(topology, currentServerDescription) {
|
||||
// update the internal server's description
|
||||
if (topology.s.servers.has(currentServerDescription.address)) {
|
||||
const server = topology.s.servers.get(currentServerDescription.address);
|
||||
server.s.description = currentServerDescription;
|
||||
}
|
||||
|
||||
// add new servers for all descriptions we currently don't know about locally
|
||||
for (const serverDescription of topology.description.servers.values()) {
|
||||
if (!topology.s.servers.has(serverDescription.address)) {
|
||||
topology.emit(
|
||||
'serverOpening',
|
||||
new monitoring.ServerOpeningEvent(topology.s.id, serverDescription.address)
|
||||
);
|
||||
|
||||
const server = new Server(serverDescription, topology.s.options);
|
||||
relayEvents(server, topology, [
|
||||
'serverHeartbeatStarted',
|
||||
'serverHeartbeatSucceeded',
|
||||
'serverHeartbeatFailed'
|
||||
]);
|
||||
|
||||
server.on('descriptionReceived', topology.serverUpdateHandler.bind(topology));
|
||||
server.on('connect', serverConnectEventHandler(server, topology));
|
||||
topology.s.servers.set(serverDescription.address, server);
|
||||
server.connect();
|
||||
}
|
||||
}
|
||||
|
||||
// for all servers no longer known, remove their descriptions and destroy their instances
|
||||
for (const entry of topology.s.servers) {
|
||||
const serverAddress = entry[0];
|
||||
if (topology.description.hasServer(serverAddress)) {
|
||||
continue;
|
||||
}
|
||||
|
||||
const server = topology.s.servers.get(serverAddress);
|
||||
topology.s.servers.delete(serverAddress);
|
||||
|
||||
server.destroy(() =>
|
||||
topology.emit('serverClosed', new monitoring.ServerClosedEvent(topology.s.id, serverAddress))
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function serverConnectEventHandler(server, topology) {
|
||||
return function(/* ismaster */) {
|
||||
topology.emit('connect', topology);
|
||||
};
|
||||
}
|
||||
|
||||
function executeWriteOperation(args, options, callback) {
|
||||
if (typeof options === 'function') (callback = options), (options = {});
|
||||
options = options || {};
|
||||
|
||||
// TODO: once we drop Node 4, use destructuring either here or in arguments.
|
||||
const topology = args.topology;
|
||||
const op = args.op;
|
||||
const ns = args.ns;
|
||||
const ops = args.ops;
|
||||
|
||||
const willRetryWrite =
|
||||
!args.retrying &&
|
||||
options.retryWrites &&
|
||||
options.session &&
|
||||
isRetryableWritesSupported(topology) &&
|
||||
!options.session.inTransaction();
|
||||
|
||||
topology.selectServer(writableServerSelector(), (err, server) => {
|
||||
if (err) {
|
||||
callback(err, null);
|
||||
return;
|
||||
}
|
||||
|
||||
const handler = (err, result) => {
|
||||
if (!err) return callback(null, result);
|
||||
if (!(err instanceof MongoNetworkError) && !err.message.match(/not master/)) {
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
if (willRetryWrite) {
|
||||
const newArgs = Object.assign({}, args, { retrying: true });
|
||||
return executeWriteOperation(newArgs, options, callback);
|
||||
}
|
||||
|
||||
return callback(err);
|
||||
};
|
||||
|
||||
if (callback.operationId) {
|
||||
handler.operationId = callback.operationId;
|
||||
}
|
||||
|
||||
// increment and assign txnNumber
|
||||
if (willRetryWrite) {
|
||||
options.session.incrementTransactionNumber();
|
||||
options.willRetryWrite = willRetryWrite;
|
||||
}
|
||||
|
||||
// execute the write operation
|
||||
server[op](ns, ops, options, handler);
|
||||
|
||||
// we need to increment the statement id if we're in a transaction
|
||||
if (options.session && options.session.inTransaction()) {
|
||||
options.session.incrementStatementId(ops.length);
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* A server opening SDAM monitoring event
|
||||
*
|
||||
* @event Topology#serverOpening
|
||||
* @type {ServerOpeningEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A server closed SDAM monitoring event
|
||||
*
|
||||
* @event Topology#serverClosed
|
||||
* @type {ServerClosedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A server description SDAM change monitoring event
|
||||
*
|
||||
* @event Topology#serverDescriptionChanged
|
||||
* @type {ServerDescriptionChangedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology open SDAM event
|
||||
*
|
||||
* @event Topology#topologyOpening
|
||||
* @type {TopologyOpeningEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology closed SDAM event
|
||||
*
|
||||
* @event Topology#topologyClosed
|
||||
* @type {TopologyClosedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology structure SDAM change event
|
||||
*
|
||||
* @event Topology#topologyDescriptionChanged
|
||||
* @type {TopologyDescriptionChangedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology serverHeartbeatStarted SDAM event
|
||||
*
|
||||
* @event Topology#serverHeartbeatStarted
|
||||
* @type {ServerHeartbeatStartedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology serverHeartbeatFailed SDAM event
|
||||
*
|
||||
* @event Topology#serverHeartbeatFailed
|
||||
* @type {ServerHearbeatFailedEvent}
|
||||
*/
|
||||
|
||||
/**
|
||||
* A topology serverHeartbeatSucceeded SDAM change event
|
||||
*
|
||||
* @event Topology#serverHeartbeatSucceeded
|
||||
* @type {ServerHeartbeatSucceededEvent}
|
||||
*/
|
||||
|
||||
module.exports = Topology;
|
||||
+364
@@ -0,0 +1,364 @@
|
||||
'use strict';
|
||||
const ServerType = require('./server_description').ServerType;
|
||||
const ServerDescription = require('./server_description').ServerDescription;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
|
||||
// contstants related to compatability checks
|
||||
const MIN_SUPPORTED_SERVER_VERSION = '2.6';
|
||||
const MIN_SUPPORTED_WIRE_VERSION = 2;
|
||||
const MAX_SUPPORTED_WIRE_VERSION = 5;
|
||||
|
||||
// An enumeration of topology types we know about
|
||||
const TopologyType = {
|
||||
Single: 'Single',
|
||||
ReplicaSetNoPrimary: 'ReplicaSetNoPrimary',
|
||||
ReplicaSetWithPrimary: 'ReplicaSetWithPrimary',
|
||||
Sharded: 'Sharded',
|
||||
Unknown: 'Unknown'
|
||||
};
|
||||
|
||||
// Representation of a deployment of servers
|
||||
class TopologyDescription {
|
||||
/**
|
||||
* Create a TopologyDescription
|
||||
*
|
||||
* @param {string} topologyType
|
||||
* @param {Map<string, ServerDescription>} serverDescriptions the a map of address to ServerDescription
|
||||
* @param {string} setName
|
||||
* @param {number} maxSetVersion
|
||||
* @param {ObjectId} maxElectionId
|
||||
*/
|
||||
constructor(topologyType, serverDescriptions, setName, maxSetVersion, maxElectionId, options) {
|
||||
options = options || {};
|
||||
|
||||
// TODO: consider assigning all these values to a temporary value `s` which
|
||||
// we use `Object.freeze` on, ensuring the internal state of this type
|
||||
// is immutable.
|
||||
this.type = topologyType || TopologyType.Unknown;
|
||||
this.setName = setName || null;
|
||||
this.maxSetVersion = maxSetVersion || null;
|
||||
this.maxElectionId = maxElectionId || null;
|
||||
this.servers = serverDescriptions || new Map();
|
||||
this.stale = false;
|
||||
this.compatible = true;
|
||||
this.compatibilityError = null;
|
||||
this.logicalSessionTimeoutMinutes = null;
|
||||
this.heartbeatFrequencyMS = options.heartbeatFrequencyMS || 0;
|
||||
this.localThresholdMS = options.localThresholdMS || 0;
|
||||
this.options = options;
|
||||
|
||||
// determine server compatibility
|
||||
for (const serverDescription of this.servers.values()) {
|
||||
if (serverDescription.minWireVersion > MAX_SUPPORTED_WIRE_VERSION) {
|
||||
this.compatible = false;
|
||||
this.compatibilityError = `Server at ${serverDescription.address} requires wire version ${
|
||||
serverDescription.minWireVersion
|
||||
}, but this version of the driver only supports up to ${MAX_SUPPORTED_WIRE_VERSION}.`;
|
||||
}
|
||||
|
||||
if (serverDescription.maxWireVersion < MIN_SUPPORTED_WIRE_VERSION) {
|
||||
this.compatible = false;
|
||||
this.compatibilityError = `Server at ${serverDescription.address} reports wire version ${
|
||||
serverDescription.maxWireVersion
|
||||
}, but this version of the driver requires at least ${MIN_SUPPORTED_WIRE_VERSION} (MongoDB ${MIN_SUPPORTED_SERVER_VERSION}).`;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Whenever a client updates the TopologyDescription from an ismaster response, it MUST set
|
||||
// TopologyDescription.logicalSessionTimeoutMinutes to the smallest logicalSessionTimeoutMinutes
|
||||
// value among ServerDescriptions of all data-bearing server types. If any have a null
|
||||
// logicalSessionTimeoutMinutes, then TopologyDescription.logicalSessionTimeoutMinutes MUST be
|
||||
// set to null.
|
||||
const readableServers = Array.from(this.servers.values()).filter(s => s.isReadable);
|
||||
this.logicalSessionTimeoutMinutes = readableServers.reduce((result, server) => {
|
||||
if (server.logicalSessionTimeoutMinutes == null) return null;
|
||||
if (result == null) return server.logicalSessionTimeoutMinutes;
|
||||
return Math.min(result, server.logicalSessionTimeoutMinutes);
|
||||
}, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns The minimum reported wire version of all known servers
|
||||
*/
|
||||
get commonWireVersion() {
|
||||
return Array.from(this.servers.values())
|
||||
.filter(server => server.type !== ServerType.Unknown)
|
||||
.reduce(
|
||||
(min, server) =>
|
||||
min == null ? server.maxWireVersion : Math.min(min, server.maxWireVersion),
|
||||
null
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Returns a copy of this description updated with a given ServerDescription
|
||||
*
|
||||
* @param {ServerDescription} serverDescription
|
||||
*/
|
||||
update(serverDescription) {
|
||||
const address = serverDescription.address;
|
||||
// NOTE: there are a number of prime targets for refactoring here
|
||||
// once we support destructuring assignments
|
||||
|
||||
// potentially mutated values
|
||||
let topologyType = this.type;
|
||||
let setName = this.setName;
|
||||
let maxSetVersion = this.maxSetVersion;
|
||||
let maxElectionId = this.maxElectionId;
|
||||
|
||||
const serverType = serverDescription.type;
|
||||
let serverDescriptions = new Map(this.servers);
|
||||
|
||||
// update the actual server description
|
||||
serverDescriptions.set(address, serverDescription);
|
||||
|
||||
if (topologyType === TopologyType.Single) {
|
||||
// once we are defined as single, that never changes
|
||||
return new TopologyDescription(
|
||||
TopologyType.Single,
|
||||
serverDescriptions,
|
||||
setName,
|
||||
maxSetVersion,
|
||||
maxElectionId,
|
||||
this.options
|
||||
);
|
||||
}
|
||||
|
||||
if (topologyType === TopologyType.Unknown) {
|
||||
if (serverType === ServerType.Standalone) {
|
||||
serverDescriptions.delete(address);
|
||||
} else {
|
||||
topologyType = topologyTypeForServerType(serverType);
|
||||
}
|
||||
}
|
||||
|
||||
if (topologyType === TopologyType.Sharded) {
|
||||
if ([ServerType.Mongos, ServerType.Unknown].indexOf(serverType) === -1) {
|
||||
serverDescriptions.delete(address);
|
||||
}
|
||||
}
|
||||
|
||||
if (topologyType === TopologyType.ReplicaSetNoPrimary) {
|
||||
if ([ServerType.Mongos, ServerType.Unknown].indexOf(serverType) >= 0) {
|
||||
serverDescriptions.delete(address);
|
||||
}
|
||||
|
||||
if (serverType === ServerType.RSPrimary) {
|
||||
const result = updateRsFromPrimary(
|
||||
serverDescriptions,
|
||||
setName,
|
||||
serverDescription,
|
||||
maxSetVersion,
|
||||
maxElectionId
|
||||
);
|
||||
|
||||
(topologyType = result[0]),
|
||||
(setName = result[1]),
|
||||
(maxSetVersion = result[2]),
|
||||
(maxElectionId = result[3]);
|
||||
} else if (
|
||||
[ServerType.RSSecondary, ServerType.RSArbiter, ServerType.RSOther].indexOf(serverType) >= 0
|
||||
) {
|
||||
const result = updateRsNoPrimaryFromMember(serverDescriptions, setName, serverDescription);
|
||||
(topologyType = result[0]), (setName = result[1]);
|
||||
}
|
||||
}
|
||||
|
||||
if (topologyType === TopologyType.ReplicaSetWithPrimary) {
|
||||
if ([ServerType.Standalone, ServerType.Mongos].indexOf(serverType) >= 0) {
|
||||
serverDescriptions.delete(address);
|
||||
topologyType = checkHasPrimary(serverDescriptions);
|
||||
} else if (serverType === ServerType.RSPrimary) {
|
||||
const result = updateRsFromPrimary(
|
||||
serverDescriptions,
|
||||
setName,
|
||||
serverDescription,
|
||||
maxSetVersion,
|
||||
maxElectionId
|
||||
);
|
||||
|
||||
(topologyType = result[0]),
|
||||
(setName = result[1]),
|
||||
(maxSetVersion = result[2]),
|
||||
(maxElectionId = result[3]);
|
||||
} else if (
|
||||
[ServerType.RSSecondary, ServerType.RSArbiter, ServerType.RSOther].indexOf(serverType) >= 0
|
||||
) {
|
||||
topologyType = updateRsWithPrimaryFromMember(
|
||||
serverDescriptions,
|
||||
setName,
|
||||
serverDescription
|
||||
);
|
||||
} else {
|
||||
topologyType = checkHasPrimary(serverDescriptions);
|
||||
}
|
||||
}
|
||||
|
||||
return new TopologyDescription(
|
||||
topologyType,
|
||||
serverDescriptions,
|
||||
setName,
|
||||
maxSetVersion,
|
||||
maxElectionId,
|
||||
this.options
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the topology has a readable server available. See the table in the
|
||||
* following section for behaviour rules.
|
||||
*
|
||||
* @param {ReadPreference} [readPreference] An optional read preference for determining if a readable server is present
|
||||
* @return {Boolean} Whether there is a readable server in this topology
|
||||
*/
|
||||
hasReadableServer(/* readPreference */) {
|
||||
// To be implemented when server selection is implemented
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the topology has a writable server available. See the table in the
|
||||
* following section for behaviour rules.
|
||||
*
|
||||
* @return {Boolean} Whether there is a writable server in this topology
|
||||
*/
|
||||
hasWritableServer() {
|
||||
return this.hasReadableServer(ReadPreference.primary);
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the topology has a definition for the provided address
|
||||
*
|
||||
* @param {String} address
|
||||
* @return {Boolean} Whether the topology knows about this server
|
||||
*/
|
||||
hasServer(address) {
|
||||
return this.servers.has(address);
|
||||
}
|
||||
}
|
||||
|
||||
function topologyTypeForServerType(serverType) {
|
||||
if (serverType === ServerType.Mongos) return TopologyType.Sharded;
|
||||
if (serverType === ServerType.RSPrimary) return TopologyType.ReplicaSetWithPrimary;
|
||||
return TopologyType.ReplicaSetNoPrimary;
|
||||
}
|
||||
|
||||
function updateRsFromPrimary(
|
||||
serverDescriptions,
|
||||
setName,
|
||||
serverDescription,
|
||||
maxSetVersion,
|
||||
maxElectionId
|
||||
) {
|
||||
setName = setName || serverDescription.setName;
|
||||
if (setName !== serverDescription.setName) {
|
||||
serverDescriptions.delete(serverDescription.address);
|
||||
return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId];
|
||||
}
|
||||
|
||||
const electionIdOID = serverDescription.electionId ? serverDescription.electionId.$oid : null;
|
||||
const maxElectionIdOID = maxElectionId ? maxElectionId.$oid : null;
|
||||
if (serverDescription.setVersion != null && electionIdOID != null) {
|
||||
if (maxSetVersion != null && maxElectionIdOID != null) {
|
||||
if (maxSetVersion > serverDescription.setVersion || maxElectionIdOID > electionIdOID) {
|
||||
// this primary is stale, we must remove it
|
||||
serverDescriptions.set(
|
||||
serverDescription.address,
|
||||
new ServerDescription(serverDescription.address)
|
||||
);
|
||||
|
||||
return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId];
|
||||
}
|
||||
}
|
||||
|
||||
maxElectionId = serverDescription.electionId;
|
||||
}
|
||||
|
||||
if (
|
||||
serverDescription.setVersion != null &&
|
||||
(maxSetVersion == null || serverDescription.setVersion > maxSetVersion)
|
||||
) {
|
||||
maxSetVersion = serverDescription.setVersion;
|
||||
}
|
||||
|
||||
// We've heard from the primary. Is it the same primary as before?
|
||||
for (const address of serverDescriptions.keys()) {
|
||||
const server = serverDescriptions.get(address);
|
||||
|
||||
if (server.type === ServerType.RSPrimary && server.address !== serverDescription.address) {
|
||||
// Reset old primary's type to Unknown.
|
||||
serverDescriptions.set(address, new ServerDescription(server.address));
|
||||
|
||||
// There can only be one primary
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Discover new hosts from this primary's response.
|
||||
serverDescription.allHosts.forEach(address => {
|
||||
if (!serverDescriptions.has(address)) {
|
||||
serverDescriptions.set(address, new ServerDescription(address));
|
||||
}
|
||||
});
|
||||
|
||||
// Remove hosts not in the response.
|
||||
const currentAddresses = Array.from(serverDescriptions.keys());
|
||||
const responseAddresses = serverDescription.allHosts;
|
||||
currentAddresses.filter(addr => responseAddresses.indexOf(addr) === -1).forEach(address => {
|
||||
serverDescriptions.delete(address);
|
||||
});
|
||||
|
||||
return [checkHasPrimary(serverDescriptions), setName, maxSetVersion, maxElectionId];
|
||||
}
|
||||
|
||||
function updateRsWithPrimaryFromMember(serverDescriptions, setName, serverDescription) {
|
||||
if (setName == null) {
|
||||
throw new TypeError('setName is required');
|
||||
}
|
||||
|
||||
if (
|
||||
setName !== serverDescription.setName ||
|
||||
(serverDescription.me && serverDescription.address !== serverDescription.me)
|
||||
) {
|
||||
serverDescriptions.delete(serverDescription.address);
|
||||
}
|
||||
|
||||
return checkHasPrimary(serverDescriptions);
|
||||
}
|
||||
|
||||
function updateRsNoPrimaryFromMember(serverDescriptions, setName, serverDescription) {
|
||||
let topologyType = TopologyType.ReplicaSetNoPrimary;
|
||||
|
||||
setName = setName || serverDescription.setName;
|
||||
if (setName !== serverDescription.setName) {
|
||||
serverDescriptions.delete(serverDescription.address);
|
||||
return [topologyType, setName];
|
||||
}
|
||||
|
||||
serverDescription.allHosts.forEach(address => {
|
||||
if (!serverDescriptions.has(address)) {
|
||||
serverDescriptions.set(address, new ServerDescription(address));
|
||||
}
|
||||
});
|
||||
|
||||
if (serverDescription.me && serverDescription.address !== serverDescription.me) {
|
||||
serverDescriptions.delete(serverDescription.address);
|
||||
}
|
||||
|
||||
return [topologyType, setName];
|
||||
}
|
||||
|
||||
function checkHasPrimary(serverDescriptions) {
|
||||
for (const addr of serverDescriptions.keys()) {
|
||||
if (serverDescriptions.get(addr).type === ServerType.RSPrimary) {
|
||||
return TopologyType.ReplicaSetWithPrimary;
|
||||
}
|
||||
}
|
||||
|
||||
return TopologyType.ReplicaSetNoPrimary;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
TopologyType,
|
||||
TopologyDescription
|
||||
};
|
||||
+459
@@ -0,0 +1,459 @@
|
||||
'use strict';
|
||||
|
||||
const retrieveBSON = require('./connection/utils').retrieveBSON;
|
||||
const EventEmitter = require('events');
|
||||
const BSON = retrieveBSON();
|
||||
const Binary = BSON.Binary;
|
||||
const uuidV4 = require('./utils').uuidV4;
|
||||
const MongoError = require('./error').MongoError;
|
||||
const isRetryableError = require('././error').isRetryableError;
|
||||
const MongoNetworkError = require('./error').MongoNetworkError;
|
||||
const MongoWriteConcernError = require('./error').MongoWriteConcernError;
|
||||
const Transaction = require('./transactions').Transaction;
|
||||
const TxnState = require('./transactions').TxnState;
|
||||
|
||||
function assertAlive(session, callback) {
|
||||
if (session.serverSession == null) {
|
||||
const error = new MongoError('Cannot use a session that has ended');
|
||||
if (typeof callback === 'function') {
|
||||
callback(error, null);
|
||||
return false;
|
||||
}
|
||||
|
||||
throw error;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/**
|
||||
* Options to pass when creating a Client Session
|
||||
* @typedef {Object} SessionOptions
|
||||
* @property {boolean} [causalConsistency=true] Whether causal consistency should be enabled on this session
|
||||
* @property {TransactionOptions} [defaultTransactionOptions] The default TransactionOptions to use for transactions started on this session.
|
||||
*/
|
||||
|
||||
/**
|
||||
* A BSON document reflecting the lsid of a {@link ClientSession}
|
||||
* @typedef {Object} SessionId
|
||||
*/
|
||||
|
||||
/**
|
||||
* A class representing a client session on the server
|
||||
* WARNING: not meant to be instantiated directly.
|
||||
* @class
|
||||
* @hideconstructor
|
||||
*/
|
||||
class ClientSession extends EventEmitter {
|
||||
/**
|
||||
* Create a client session.
|
||||
* WARNING: not meant to be instantiated directly
|
||||
*
|
||||
* @param {Topology} topology The current client's topology (Internal Class)
|
||||
* @param {ServerSessionPool} sessionPool The server session pool (Internal Class)
|
||||
* @param {SessionOptions} [options] Optional settings
|
||||
* @param {Object} [clientOptions] Optional settings provided when creating a client in the porcelain driver
|
||||
*/
|
||||
constructor(topology, sessionPool, options, clientOptions) {
|
||||
super();
|
||||
|
||||
if (topology == null) {
|
||||
throw new Error('ClientSession requires a topology');
|
||||
}
|
||||
|
||||
if (sessionPool == null || !(sessionPool instanceof ServerSessionPool)) {
|
||||
throw new Error('ClientSession requires a ServerSessionPool');
|
||||
}
|
||||
|
||||
options = options || {};
|
||||
this.topology = topology;
|
||||
this.sessionPool = sessionPool;
|
||||
this.hasEnded = false;
|
||||
this.serverSession = sessionPool.acquire();
|
||||
this.clientOptions = clientOptions;
|
||||
|
||||
this.supports = {
|
||||
causalConsistency:
|
||||
typeof options.causalConsistency !== 'undefined' ? options.causalConsistency : true
|
||||
};
|
||||
|
||||
options = options || {};
|
||||
if (typeof options.initialClusterTime !== 'undefined') {
|
||||
this.clusterTime = options.initialClusterTime;
|
||||
} else {
|
||||
this.clusterTime = null;
|
||||
}
|
||||
|
||||
this.operationTime = null;
|
||||
this.explicit = !!options.explicit;
|
||||
this.owner = options.owner;
|
||||
this.defaultTransactionOptions = Object.assign({}, options.defaultTransactionOptions);
|
||||
this.transaction = new Transaction();
|
||||
}
|
||||
|
||||
/**
|
||||
* The server id associated with this session
|
||||
* @type {SessionId}
|
||||
*/
|
||||
get id() {
|
||||
return this.serverSession.id;
|
||||
}
|
||||
|
||||
/**
|
||||
* Ends this session on the server
|
||||
*
|
||||
* @param {Object} [options] Optional settings. Currently reserved for future use
|
||||
* @param {Function} [callback] Optional callback for completion of this operation
|
||||
*/
|
||||
endSession(options, callback) {
|
||||
if (typeof options === 'function') (callback = options), (options = {});
|
||||
options = options || {};
|
||||
|
||||
if (this.hasEnded) {
|
||||
if (typeof callback === 'function') callback(null, null);
|
||||
return;
|
||||
}
|
||||
|
||||
if (this.serverSession && this.inTransaction()) {
|
||||
this.abortTransaction(); // pass in callback?
|
||||
}
|
||||
|
||||
// mark the session as ended, and emit a signal
|
||||
this.hasEnded = true;
|
||||
this.emit('ended', this);
|
||||
|
||||
// release the server session back to the pool
|
||||
this.sessionPool.release(this.serverSession);
|
||||
|
||||
// spec indicates that we should ignore all errors for `endSessions`
|
||||
if (typeof callback === 'function') callback(null, null);
|
||||
}
|
||||
|
||||
/**
|
||||
* Advances the operationTime for a ClientSession.
|
||||
*
|
||||
* @param {Timestamp} operationTime the `BSON.Timestamp` of the operation type it is desired to advance to
|
||||
*/
|
||||
advanceOperationTime(operationTime) {
|
||||
if (this.operationTime == null) {
|
||||
this.operationTime = operationTime;
|
||||
return;
|
||||
}
|
||||
|
||||
if (operationTime.greaterThan(this.operationTime)) {
|
||||
this.operationTime = operationTime;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Used to determine if this session equals another
|
||||
* @param {ClientSession} session
|
||||
* @return {boolean} true if the sessions are equal
|
||||
*/
|
||||
equals(session) {
|
||||
if (!(session instanceof ClientSession)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return this.id.id.buffer.equals(session.id.id.buffer);
|
||||
}
|
||||
|
||||
/**
|
||||
* Increment the transaction number on the internal ServerSession
|
||||
*/
|
||||
incrementTransactionNumber() {
|
||||
this.serverSession.txnNumber++;
|
||||
}
|
||||
|
||||
/**
|
||||
* @returns {boolean} whether this session is currently in a transaction or not
|
||||
*/
|
||||
inTransaction() {
|
||||
return this.transaction.isActive;
|
||||
}
|
||||
|
||||
/**
|
||||
* Starts a new transaction with the given options.
|
||||
*
|
||||
* @param {TransactionOptions} options Options for the transaction
|
||||
*/
|
||||
startTransaction(options) {
|
||||
assertAlive(this);
|
||||
if (this.inTransaction()) {
|
||||
throw new MongoError('Transaction already in progress');
|
||||
}
|
||||
|
||||
// increment txnNumber
|
||||
this.incrementTransactionNumber();
|
||||
|
||||
// create transaction state
|
||||
this.transaction = new Transaction(
|
||||
Object.assign({}, this.clientOptions, options || this.defaultTransactionOptions)
|
||||
);
|
||||
|
||||
this.transaction.transition(TxnState.STARTING_TRANSACTION);
|
||||
}
|
||||
|
||||
/**
|
||||
* Commits the currently active transaction in this session.
|
||||
*
|
||||
* @param {Function} [callback] optional callback for completion of this operation
|
||||
* @return {Promise} A promise is returned if no callback is provided
|
||||
*/
|
||||
commitTransaction(callback) {
|
||||
if (typeof callback === 'function') {
|
||||
endTransaction(this, 'commitTransaction', callback);
|
||||
return;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
endTransaction(
|
||||
this,
|
||||
'commitTransaction',
|
||||
(err, reply) => (err ? reject(err) : resolve(reply))
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Aborts the currently active transaction in this session.
|
||||
*
|
||||
* @param {Function} [callback] optional callback for completion of this operation
|
||||
* @return {Promise} A promise is returned if no callback is provided
|
||||
*/
|
||||
abortTransaction(callback) {
|
||||
if (typeof callback === 'function') {
|
||||
endTransaction(this, 'abortTransaction', callback);
|
||||
return;
|
||||
}
|
||||
|
||||
return new Promise((resolve, reject) => {
|
||||
endTransaction(
|
||||
this,
|
||||
'abortTransaction',
|
||||
(err, reply) => (err ? reject(err) : resolve(reply))
|
||||
);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* This is here to ensure that ClientSession is never serialized to BSON.
|
||||
* @ignore
|
||||
*/
|
||||
toBSON() {
|
||||
throw new Error('ClientSession cannot be serialized to BSON.');
|
||||
}
|
||||
}
|
||||
|
||||
function endTransaction(session, commandName, callback) {
|
||||
if (!assertAlive(session, callback)) {
|
||||
// checking result in case callback was called
|
||||
return;
|
||||
}
|
||||
|
||||
// handle any initial problematic cases
|
||||
let txnState = session.transaction.state;
|
||||
|
||||
if (txnState === TxnState.NO_TRANSACTION) {
|
||||
callback(new MongoError('No transaction started'));
|
||||
return;
|
||||
}
|
||||
|
||||
if (commandName === 'commitTransaction') {
|
||||
if (
|
||||
txnState === TxnState.STARTING_TRANSACTION ||
|
||||
txnState === TxnState.TRANSACTION_COMMITTED_EMPTY
|
||||
) {
|
||||
// the transaction was never started, we can safely exit here
|
||||
session.transaction.transition(TxnState.TRANSACTION_COMMITTED_EMPTY);
|
||||
callback(null, null);
|
||||
return;
|
||||
}
|
||||
|
||||
if (txnState === TxnState.TRANSACTION_ABORTED) {
|
||||
callback(new MongoError('Cannot call commitTransaction after calling abortTransaction'));
|
||||
return;
|
||||
}
|
||||
} else {
|
||||
if (txnState === TxnState.STARTING_TRANSACTION) {
|
||||
// the transaction was never started, we can safely exit here
|
||||
session.transaction.transition(TxnState.TRANSACTION_ABORTED);
|
||||
callback(null, null);
|
||||
return;
|
||||
}
|
||||
|
||||
if (txnState === TxnState.TRANSACTION_ABORTED) {
|
||||
callback(new MongoError('Cannot call abortTransaction twice'));
|
||||
return;
|
||||
}
|
||||
|
||||
if (
|
||||
txnState === TxnState.TRANSACTION_COMMITTED ||
|
||||
txnState === TxnState.TRANSACTION_COMMITTED_EMPTY
|
||||
) {
|
||||
callback(new MongoError('Cannot call abortTransaction after calling commitTransaction'));
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
// construct and send the command
|
||||
const command = { [commandName]: 1 };
|
||||
|
||||
// apply a writeConcern if specified
|
||||
if (session.transaction.options.writeConcern) {
|
||||
Object.assign(command, { writeConcern: session.transaction.options.writeConcern });
|
||||
} else if (session.clientOptions && session.clientOptions.w) {
|
||||
Object.assign(command, { writeConcern: { w: session.clientOptions.w } });
|
||||
}
|
||||
|
||||
function commandHandler(e, r) {
|
||||
if (commandName === 'commitTransaction') {
|
||||
session.transaction.transition(TxnState.TRANSACTION_COMMITTED);
|
||||
|
||||
if (
|
||||
e &&
|
||||
(e instanceof MongoNetworkError ||
|
||||
e instanceof MongoWriteConcernError ||
|
||||
isRetryableError(e))
|
||||
) {
|
||||
if (e.errorLabels) {
|
||||
const idx = e.errorLabels.indexOf('TransientTransactionError');
|
||||
if (idx !== -1) {
|
||||
e.errorLabels.splice(idx, 1);
|
||||
}
|
||||
} else {
|
||||
e.errorLabels = [];
|
||||
}
|
||||
|
||||
e.errorLabels.push('UnknownTransactionCommitResult');
|
||||
}
|
||||
} else {
|
||||
session.transaction.transition(TxnState.TRANSACTION_ABORTED);
|
||||
}
|
||||
|
||||
callback(e, r);
|
||||
}
|
||||
|
||||
// The spec indicates that we should ignore all errors on `abortTransaction`
|
||||
function transactionError(err) {
|
||||
return commandName === 'commitTransaction' ? err : null;
|
||||
}
|
||||
|
||||
// send the command
|
||||
session.topology.command('admin.$cmd', command, { session }, (err, reply) => {
|
||||
if (err && isRetryableError(err)) {
|
||||
return session.topology.command('admin.$cmd', command, { session }, (_err, _reply) =>
|
||||
commandHandler(transactionError(_err), _reply)
|
||||
);
|
||||
}
|
||||
|
||||
commandHandler(transactionError(err), reply);
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Reflects the existence of a session on the server. Can be reused by the session pool.
|
||||
* WARNING: not meant to be instantiated directly. For internal use only.
|
||||
* @ignore
|
||||
*/
|
||||
class ServerSession {
|
||||
constructor() {
|
||||
this.id = { id: new Binary(uuidV4(), Binary.SUBTYPE_UUID) };
|
||||
this.lastUse = Date.now();
|
||||
this.txnNumber = 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* Determines if the server session has timed out.
|
||||
* @ignore
|
||||
* @param {Date} sessionTimeoutMinutes The server's "logicalSessionTimeoutMinutes"
|
||||
* @return {boolean} true if the session has timed out.
|
||||
*/
|
||||
hasTimedOut(sessionTimeoutMinutes) {
|
||||
// Take the difference of the lastUse timestamp and now, which will result in a value in
|
||||
// milliseconds, and then convert milliseconds to minutes to compare to `sessionTimeoutMinutes`
|
||||
const idleTimeMinutes = Math.round(
|
||||
(((Date.now() - this.lastUse) % 86400000) % 3600000) / 60000
|
||||
);
|
||||
|
||||
return idleTimeMinutes > sessionTimeoutMinutes - 1;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Maintains a pool of Server Sessions.
|
||||
* For internal use only
|
||||
* @ignore
|
||||
*/
|
||||
class ServerSessionPool {
|
||||
constructor(topology) {
|
||||
if (topology == null) {
|
||||
throw new Error('ServerSessionPool requires a topology');
|
||||
}
|
||||
|
||||
this.topology = topology;
|
||||
this.sessions = [];
|
||||
}
|
||||
|
||||
/**
|
||||
* Ends all sessions in the session pool.
|
||||
* @ignore
|
||||
*/
|
||||
endAllPooledSessions() {
|
||||
if (this.sessions.length) {
|
||||
this.topology.endSessions(this.sessions.map(session => session.id));
|
||||
this.sessions = [];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Acquire a Server Session from the pool.
|
||||
* Iterates through each session in the pool, removing any stale sessions
|
||||
* along the way. The first non-stale session found is removed from the
|
||||
* pool and returned. If no non-stale session is found, a new ServerSession
|
||||
* is created.
|
||||
* @ignore
|
||||
* @returns {ServerSession}
|
||||
*/
|
||||
acquire() {
|
||||
const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes;
|
||||
while (this.sessions.length) {
|
||||
const session = this.sessions.shift();
|
||||
if (!session.hasTimedOut(sessionTimeoutMinutes)) {
|
||||
return session;
|
||||
}
|
||||
}
|
||||
|
||||
return new ServerSession();
|
||||
}
|
||||
|
||||
/**
|
||||
* Release a session to the session pool
|
||||
* Adds the session back to the session pool if the session has not timed out yet.
|
||||
* This method also removes any stale sessions from the pool.
|
||||
* @ignore
|
||||
* @param {ServerSession} session The session to release to the pool
|
||||
*/
|
||||
release(session) {
|
||||
const sessionTimeoutMinutes = this.topology.logicalSessionTimeoutMinutes;
|
||||
while (this.sessions.length) {
|
||||
const session = this.sessions[this.sessions.length - 1];
|
||||
if (session.hasTimedOut(sessionTimeoutMinutes)) {
|
||||
this.sessions.pop();
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!session.hasTimedOut(sessionTimeoutMinutes)) {
|
||||
this.sessions.unshift(session);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
ClientSession,
|
||||
ServerSession,
|
||||
ServerSessionPool,
|
||||
TxnState
|
||||
};
|
||||
+61
@@ -0,0 +1,61 @@
|
||||
'use strict';
|
||||
|
||||
var fs = require('fs');
|
||||
|
||||
/* Note: because this plugin uses process.on('uncaughtException'), only one
|
||||
* of these can exist at any given time. This plugin and anything else that
|
||||
* uses process.on('uncaughtException') will conflict. */
|
||||
exports.attachToRunner = function(runner, outputFile) {
|
||||
var smokeOutput = { results: [] };
|
||||
var runningTests = {};
|
||||
|
||||
var integraPlugin = {
|
||||
beforeTest: function(test, callback) {
|
||||
test.startTime = Date.now();
|
||||
runningTests[test.name] = test;
|
||||
callback();
|
||||
},
|
||||
afterTest: function(test, callback) {
|
||||
smokeOutput.results.push({
|
||||
status: test.status,
|
||||
start: test.startTime,
|
||||
end: Date.now(),
|
||||
test_file: test.name,
|
||||
exit_code: 0,
|
||||
url: ''
|
||||
});
|
||||
delete runningTests[test.name];
|
||||
callback();
|
||||
},
|
||||
beforeExit: function(obj, callback) {
|
||||
fs.writeFile(outputFile, JSON.stringify(smokeOutput), function() {
|
||||
callback();
|
||||
});
|
||||
}
|
||||
};
|
||||
|
||||
// In case of exception, make sure we write file
|
||||
process.on('uncaughtException', function(err) {
|
||||
// Mark all currently running tests as failed
|
||||
for (var testName in runningTests) {
|
||||
smokeOutput.results.push({
|
||||
status: 'fail',
|
||||
start: runningTests[testName].startTime,
|
||||
end: Date.now(),
|
||||
test_file: testName,
|
||||
exit_code: 0,
|
||||
url: ''
|
||||
});
|
||||
}
|
||||
|
||||
// write file
|
||||
fs.writeFileSync(outputFile, JSON.stringify(smokeOutput));
|
||||
|
||||
// Standard NodeJS uncaught exception handler
|
||||
console.error(err.stack);
|
||||
process.exit(1);
|
||||
});
|
||||
|
||||
runner.plugin(integraPlugin);
|
||||
return integraPlugin;
|
||||
};
|
||||
+1506
File diff suppressed because it is too large.
Load diff
+193
@@ -0,0 +1,193 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* The **ReadPreference** class is a class that represents a MongoDB ReadPreference and is
|
||||
* used to construct connections.
|
||||
* @class
|
||||
* @param {string} mode A string describing the read preference mode (primary|primaryPreferred|secondary|secondaryPreferred|nearest)
|
||||
* @param {array} tags The tags object
|
||||
* @param {object} [options] Additional read preference options
|
||||
* @param {number} [options.maxStalenessSeconds] Max secondary read staleness in seconds, Minimum value is 90 seconds.
|
||||
* @return {ReadPreference}
|
||||
* @example
|
||||
* const ReplSet = require('mongodb-core').ReplSet,
|
||||
* ReadPreference = require('mongodb-core').ReadPreference,
|
||||
* assert = require('assert');
|
||||
*
|
||||
* const server = new ReplSet([{host: 'localhost', port: 30000}], {setName: 'rs'});
|
||||
* // Wait for the connection event
|
||||
* server.on('connect', function(server) {
|
||||
* const cursor = server.cursor(
|
||||
* 'db.test',
|
||||
* { find: 'db.test', query: {} },
|
||||
* { readPreference: new ReadPreference('secondary') }
|
||||
* );
|
||||
*
|
||||
* cursor.next(function(err, doc) {
|
||||
* server.destroy();
|
||||
* });
|
||||
* });
|
||||
*
|
||||
* // Start connecting
|
||||
* server.connect();
|
||||
* @see https://docs.mongodb.com/manual/core/read-preference/
|
||||
*/
|
||||
const ReadPreference = function(mode, tags, options) {
|
||||
// TODO(major): tags MUST be an array of tagsets
|
||||
if (tags && !Array.isArray(tags)) {
|
||||
console.warn(
|
||||
'ReadPreference tags must be an array, this will change in the next major version'
|
||||
);
|
||||
|
||||
if (typeof tags.maxStalenessSeconds !== 'undefined') {
|
||||
// this is likely an options object
|
||||
options = tags;
|
||||
tags = undefined;
|
||||
} else {
|
||||
tags = [tags];
|
||||
}
|
||||
}
|
||||
|
||||
this.mode = mode;
|
||||
this.tags = tags;
|
||||
|
||||
options = options || {};
|
||||
if (options.maxStalenessSeconds != null) {
|
||||
if (options.maxStalenessSeconds <= 0) {
|
||||
throw new TypeError('maxStalenessSeconds must be a positive integer');
|
||||
}
|
||||
|
||||
this.maxStalenessSeconds = options.maxStalenessSeconds;
|
||||
|
||||
// NOTE: The minimum required wire version is 5 for this read preference. If the existing
|
||||
// topology has a lower value then a MongoError will be thrown during server selection.
|
||||
this.minWireVersion = 5;
|
||||
}
|
||||
|
||||
if (this.mode === ReadPreference.PRIMARY || this.mode === true) {
|
||||
if (this.tags && Array.isArray(this.tags) && this.tags.length > 0) {
|
||||
throw new TypeError('Primary read preference cannot be combined with tags');
|
||||
}
|
||||
|
||||
if (this.maxStalenessSeconds) {
|
||||
throw new TypeError('Primary read preference cannot be combined with maxStalenessSeconds');
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
// Support the deprecated `preference` property introduced in the porcelain layer
|
||||
Object.defineProperty(ReadPreference.prototype, 'preference', {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return this.mode;
|
||||
}
|
||||
});
|
||||
|
||||
/*
|
||||
* Read preference mode constants
|
||||
*/
|
||||
ReadPreference.PRIMARY = 'primary';
|
||||
ReadPreference.PRIMARY_PREFERRED = 'primaryPreferred';
|
||||
ReadPreference.SECONDARY = 'secondary';
|
||||
ReadPreference.SECONDARY_PREFERRED = 'secondaryPreferred';
|
||||
ReadPreference.NEAREST = 'nearest';
|
||||
|
||||
const VALID_MODES = [
|
||||
ReadPreference.PRIMARY,
|
||||
ReadPreference.PRIMARY_PREFERRED,
|
||||
ReadPreference.SECONDARY,
|
||||
ReadPreference.SECONDARY_PREFERRED,
|
||||
ReadPreference.NEAREST,
|
||||
true,
|
||||
false,
|
||||
null
|
||||
];
|
||||
|
||||
/**
|
||||
* Validate if a mode is legal
|
||||
*
|
||||
* @method
|
||||
* @param {string} mode The string representing the read preference mode.
|
||||
* @return {boolean} True if a mode is valid
|
||||
*/
|
||||
ReadPreference.isValid = function(mode) {
|
||||
return VALID_MODES.indexOf(mode) !== -1;
|
||||
};
|
||||
|
||||
/**
|
||||
* Validate if a mode is legal
|
||||
*
|
||||
* @method
|
||||
* @param {string} mode The string representing the read preference mode.
|
||||
* @return {boolean} True if a mode is valid
|
||||
*/
|
||||
ReadPreference.prototype.isValid = function(mode) {
|
||||
return ReadPreference.isValid(typeof mode === 'string' ? mode : this.mode);
|
||||
};
|
||||
|
||||
const needSlaveOk = ['primaryPreferred', 'secondary', 'secondaryPreferred', 'nearest'];
|
||||
|
||||
/**
|
||||
* Indicates that this readPreference needs the "slaveOk" bit when sent over the wire
|
||||
* @method
|
||||
* @return {boolean}
|
||||
* @see https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#op-query
|
||||
*/
|
||||
ReadPreference.prototype.slaveOk = function() {
|
||||
return needSlaveOk.indexOf(this.mode) !== -1;
|
||||
};
|
||||
|
||||
/**
|
||||
* Are the two read preference equal
|
||||
* @method
|
||||
* @param {ReadPreference} readPreference The read preference with which to check equality
|
||||
* @return {boolean} True if the two ReadPreferences are equivalent
|
||||
*/
|
||||
ReadPreference.prototype.equals = function(readPreference) {
|
||||
return readPreference.mode === this.mode;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return JSON representation
|
||||
* @method
|
||||
* @return {Object} A JSON representation of the ReadPreference
|
||||
*/
|
||||
ReadPreference.prototype.toJSON = function() {
|
||||
const readPreference = { mode: this.mode };
|
||||
if (Array.isArray(this.tags)) readPreference.tags = this.tags;
|
||||
if (this.maxStalenessSeconds) readPreference.maxStalenessSeconds = this.maxStalenessSeconds;
|
||||
return readPreference;
|
||||
};
|
||||
|
||||
/**
|
||||
* Primary read preference
|
||||
* @member
|
||||
* @type {ReadPreference}
|
||||
*/
|
||||
ReadPreference.primary = new ReadPreference('primary');
|
||||
/**
|
||||
* Primary Preferred read preference
|
||||
* @member
|
||||
* @type {ReadPreference}
|
||||
*/
|
||||
ReadPreference.primaryPreferred = new ReadPreference('primaryPreferred');
|
||||
/**
|
||||
* Secondary read preference
|
||||
* @member
|
||||
* @type {ReadPreference}
|
||||
*/
|
||||
ReadPreference.secondary = new ReadPreference('secondary');
|
||||
/**
|
||||
* Secondary Preferred read preference
|
||||
* @member
|
||||
* @type {ReadPreference}
|
||||
*/
|
||||
ReadPreference.secondaryPreferred = new ReadPreference('secondaryPreferred');
|
||||
/**
|
||||
* Nearest read preference
|
||||
* @member
|
||||
* @type {ReadPreference}
|
||||
*/
|
||||
ReadPreference.nearest = new ReadPreference('nearest');
|
||||
|
||||
module.exports = ReadPreference;
|
||||
+1722
File diff suppressed because it is too large.
Load diff
+1099
File diff suppressed because it is too large.
Load diff
+1143
File diff suppressed because it is too large.
Load diff
+434
@@ -0,0 +1,434 @@
|
||||
'use strict';
|
||||
|
||||
const os = require('os');
|
||||
const f = require('util').format;
|
||||
const ReadPreference = require('./read_preference');
|
||||
const Buffer = require('safe-buffer').Buffer;
|
||||
|
||||
/**
|
||||
* Emit event if it exists
|
||||
* @method
|
||||
*/
|
||||
function emitSDAMEvent(self, event, description) {
|
||||
if (self.listeners(event).length > 0) {
|
||||
self.emit(event, description);
|
||||
}
|
||||
}
|
||||
|
||||
// Get package.json variable
|
||||
var driverVersion = require('../../package.json').version;
|
||||
var nodejsversion = f('Node.js %s, %s', process.version, os.endianness());
|
||||
var type = os.type();
|
||||
var name = process.platform;
|
||||
var architecture = process.arch;
|
||||
var release = os.release();
|
||||
|
||||
function createClientInfo(options) {
|
||||
// Build default client information
|
||||
var clientInfo = options.clientInfo
|
||||
? clone(options.clientInfo)
|
||||
: {
|
||||
driver: {
|
||||
name: 'nodejs-core',
|
||||
version: driverVersion
|
||||
},
|
||||
os: {
|
||||
type: type,
|
||||
name: name,
|
||||
architecture: architecture,
|
||||
version: release
|
||||
}
|
||||
};
|
||||
|
||||
// Is platform specified
|
||||
if (clientInfo.platform && clientInfo.platform.indexOf('mongodb-core') === -1) {
|
||||
clientInfo.platform = f('%s, mongodb-core: %s', clientInfo.platform, driverVersion);
|
||||
} else if (!clientInfo.platform) {
|
||||
clientInfo.platform = nodejsversion;
|
||||
}
|
||||
|
||||
// Do we have an application specific string
|
||||
if (options.appname) {
|
||||
// Cut at 128 bytes
|
||||
var buffer = Buffer.from(options.appname);
|
||||
// Return the truncated appname
|
||||
var appname = buffer.length > 128 ? buffer.slice(0, 128).toString('utf8') : options.appname;
|
||||
// Add to the clientInfo
|
||||
clientInfo.application = { name: appname };
|
||||
}
|
||||
|
||||
return clientInfo;
|
||||
}
|
||||
|
||||
function createCompressionInfo(options) {
|
||||
if (!options.compression || !options.compression.compressors) {
|
||||
return [];
|
||||
}
|
||||
|
||||
// Check that all supplied compressors are valid
|
||||
options.compression.compressors.forEach(function(compressor) {
|
||||
if (compressor !== 'snappy' && compressor !== 'zlib') {
|
||||
throw new Error('compressors must be at least one of snappy or zlib');
|
||||
}
|
||||
});
|
||||
|
||||
return options.compression.compressors;
|
||||
}
|
||||
|
||||
function clone(object) {
|
||||
return JSON.parse(JSON.stringify(object));
|
||||
}
|
||||
|
||||
var getPreviousDescription = function(self) {
|
||||
if (!self.s.serverDescription) {
|
||||
self.s.serverDescription = {
|
||||
address: self.name,
|
||||
arbiters: [],
|
||||
hosts: [],
|
||||
passives: [],
|
||||
type: 'Unknown'
|
||||
};
|
||||
}
|
||||
|
||||
return self.s.serverDescription;
|
||||
};
|
||||
|
||||
var emitServerDescriptionChanged = function(self, description) {
|
||||
if (self.listeners('serverDescriptionChanged').length > 0) {
|
||||
// Emit the server description changed events
|
||||
self.emit('serverDescriptionChanged', {
|
||||
topologyId: self.s.topologyId !== -1 ? self.s.topologyId : self.id,
|
||||
address: self.name,
|
||||
previousDescription: getPreviousDescription(self),
|
||||
newDescription: description
|
||||
});
|
||||
|
||||
self.s.serverDescription = description;
|
||||
}
|
||||
};
|
||||
|
||||
var getPreviousTopologyDescription = function(self) {
|
||||
if (!self.s.topologyDescription) {
|
||||
self.s.topologyDescription = {
|
||||
topologyType: 'Unknown',
|
||||
servers: [
|
||||
{
|
||||
address: self.name,
|
||||
arbiters: [],
|
||||
hosts: [],
|
||||
passives: [],
|
||||
type: 'Unknown'
|
||||
}
|
||||
]
|
||||
};
|
||||
}
|
||||
|
||||
return self.s.topologyDescription;
|
||||
};
|
||||
|
||||
var emitTopologyDescriptionChanged = function(self, description) {
|
||||
if (self.listeners('topologyDescriptionChanged').length > 0) {
|
||||
// Emit the server description changed events
|
||||
self.emit('topologyDescriptionChanged', {
|
||||
topologyId: self.s.topologyId !== -1 ? self.s.topologyId : self.id,
|
||||
address: self.name,
|
||||
previousDescription: getPreviousTopologyDescription(self),
|
||||
newDescription: description
|
||||
});
|
||||
|
||||
self.s.serverDescription = description;
|
||||
}
|
||||
};
|
||||
|
||||
var changedIsMaster = function(self, currentIsmaster, ismaster) {
|
||||
var currentType = getTopologyType(self, currentIsmaster);
|
||||
var newType = getTopologyType(self, ismaster);
|
||||
if (newType !== currentType) return true;
|
||||
return false;
|
||||
};
|
||||
|
||||
var getTopologyType = function(self, ismaster) {
|
||||
if (!ismaster) {
|
||||
ismaster = self.ismaster;
|
||||
}
|
||||
|
||||
if (!ismaster) return 'Unknown';
|
||||
if (ismaster.ismaster && ismaster.msg === 'isdbgrid') return 'Mongos';
|
||||
if (ismaster.ismaster && !ismaster.hosts) return 'Standalone';
|
||||
if (ismaster.ismaster) return 'RSPrimary';
|
||||
if (ismaster.secondary) return 'RSSecondary';
|
||||
if (ismaster.arbiterOnly) return 'RSArbiter';
|
||||
return 'Unknown';
|
||||
};
|
||||
|
||||
var inquireServerState = function(self) {
|
||||
return function(callback) {
|
||||
if (self.s.state === 'destroyed') return;
|
||||
// Record response time
|
||||
var start = new Date().getTime();
|
||||
|
||||
// emitSDAMEvent
|
||||
emitSDAMEvent(self, 'serverHeartbeatStarted', { connectionId: self.name });
|
||||
|
||||
// Attempt to execute ismaster command
|
||||
self.command('admin.$cmd', { ismaster: true }, { monitoring: true }, function(err, r) {
|
||||
if (!err) {
|
||||
// Legacy event sender
|
||||
self.emit('ismaster', r, self);
|
||||
|
||||
// Calculate latencyMS
|
||||
var latencyMS = new Date().getTime() - start;
|
||||
|
||||
// Server heart beat event
|
||||
emitSDAMEvent(self, 'serverHeartbeatSucceeded', {
|
||||
durationMS: latencyMS,
|
||||
reply: r.result,
|
||||
connectionId: self.name
|
||||
});
|
||||
|
||||
// Did the server change
|
||||
if (changedIsMaster(self, self.s.ismaster, r.result)) {
|
||||
// Emit server description changed if something listening
|
||||
emitServerDescriptionChanged(self, {
|
||||
address: self.name,
|
||||
arbiters: [],
|
||||
hosts: [],
|
||||
passives: [],
|
||||
type: !self.s.inTopology ? 'Standalone' : getTopologyType(self)
|
||||
});
|
||||
}
|
||||
|
||||
// Updat ismaster view
|
||||
self.s.ismaster = r.result;
|
||||
|
||||
// Set server response time
|
||||
self.s.isMasterLatencyMS = latencyMS;
|
||||
} else {
|
||||
emitSDAMEvent(self, 'serverHeartbeatFailed', {
|
||||
durationMS: latencyMS,
|
||||
failure: err,
|
||||
connectionId: self.name
|
||||
});
|
||||
}
|
||||
|
||||
// Peforming an ismaster monitoring callback operation
|
||||
if (typeof callback === 'function') {
|
||||
return callback(err, r);
|
||||
}
|
||||
|
||||
// Perform another sweep
|
||||
self.s.inquireServerStateTimeout = setTimeout(inquireServerState(self), self.s.haInterval);
|
||||
});
|
||||
};
|
||||
};
|
||||
|
||||
//
|
||||
// Clone the options
|
||||
var cloneOptions = function(options) {
|
||||
var opts = {};
|
||||
for (var name in options) {
|
||||
opts[name] = options[name];
|
||||
}
|
||||
return opts;
|
||||
};
|
||||
|
||||
function Interval(fn, time) {
|
||||
var timer = false;
|
||||
|
||||
this.start = function() {
|
||||
if (!this.isRunning()) {
|
||||
timer = setInterval(fn, time);
|
||||
}
|
||||
|
||||
return this;
|
||||
};
|
||||
|
||||
this.stop = function() {
|
||||
clearInterval(timer);
|
||||
timer = false;
|
||||
return this;
|
||||
};
|
||||
|
||||
this.isRunning = function() {
|
||||
return timer !== false;
|
||||
};
|
||||
}
|
||||
|
||||
function Timeout(fn, time) {
|
||||
var timer = false;
|
||||
|
||||
this.start = function() {
|
||||
if (!this.isRunning()) {
|
||||
timer = setTimeout(fn, time);
|
||||
}
|
||||
return this;
|
||||
};
|
||||
|
||||
this.stop = function() {
|
||||
clearTimeout(timer);
|
||||
timer = false;
|
||||
return this;
|
||||
};
|
||||
|
||||
this.isRunning = function() {
|
||||
if (timer && timer._called) return false;
|
||||
return timer !== false;
|
||||
};
|
||||
}
|
||||
|
||||
function diff(previous, current) {
|
||||
// Difference document
|
||||
var diff = {
|
||||
servers: []
|
||||
};
|
||||
|
||||
// Previous entry
|
||||
if (!previous) {
|
||||
previous = { servers: [] };
|
||||
}
|
||||
|
||||
// Check if we have any previous servers missing in the current ones
|
||||
for (var i = 0; i < previous.servers.length; i++) {
|
||||
var found = false;
|
||||
|
||||
for (var j = 0; j < current.servers.length; j++) {
|
||||
if (current.servers[j].address.toLowerCase() === previous.servers[i].address.toLowerCase()) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (!found) {
|
||||
// Add to the diff
|
||||
diff.servers.push({
|
||||
address: previous.servers[i].address,
|
||||
from: previous.servers[i].type,
|
||||
to: 'Unknown'
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Check if there are any severs that don't exist
|
||||
for (j = 0; j < current.servers.length; j++) {
|
||||
found = false;
|
||||
|
||||
// Go over all the previous servers
|
||||
for (i = 0; i < previous.servers.length; i++) {
|
||||
if (previous.servers[i].address.toLowerCase() === current.servers[j].address.toLowerCase()) {
|
||||
found = true;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
// Add the server to the diff
|
||||
if (!found) {
|
||||
diff.servers.push({
|
||||
address: current.servers[j].address,
|
||||
from: 'Unknown',
|
||||
to: current.servers[j].type
|
||||
});
|
||||
}
|
||||
}
|
||||
|
||||
// Got through all the servers
|
||||
for (i = 0; i < previous.servers.length; i++) {
|
||||
var prevServer = previous.servers[i];
|
||||
|
||||
// Go through all current servers
|
||||
for (j = 0; j < current.servers.length; j++) {
|
||||
var currServer = current.servers[j];
|
||||
|
||||
// Matching server
|
||||
if (prevServer.address.toLowerCase() === currServer.address.toLowerCase()) {
|
||||
// We had a change in state
|
||||
if (prevServer.type !== currServer.type) {
|
||||
diff.servers.push({
|
||||
address: prevServer.address,
|
||||
from: prevServer.type,
|
||||
to: currServer.type
|
||||
});
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Return difference
|
||||
return diff;
|
||||
}
|
||||
|
||||
/**
|
||||
* Shared function to determine clusterTime for a given topology
|
||||
*
|
||||
* @param {*} topology
|
||||
* @param {*} clusterTime
|
||||
*/
|
||||
function resolveClusterTime(topology, $clusterTime) {
|
||||
if (topology.clusterTime == null) {
|
||||
topology.clusterTime = $clusterTime;
|
||||
} else {
|
||||
if ($clusterTime.clusterTime.greaterThan(topology.clusterTime.clusterTime)) {
|
||||
topology.clusterTime = $clusterTime;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// NOTE: this is a temporary move until the topologies can be more formally refactored
|
||||
// to share code.
|
||||
const SessionMixins = {
|
||||
endSessions: function(sessions, callback) {
|
||||
if (!Array.isArray(sessions)) {
|
||||
sessions = [sessions];
|
||||
}
|
||||
|
||||
// TODO:
|
||||
// When connected to a sharded cluster the endSessions command
|
||||
// can be sent to any mongos. When connected to a replica set the
|
||||
// endSessions command MUST be sent to the primary if the primary
|
||||
// is available, otherwise it MUST be sent to any available secondary.
|
||||
// Is it enough to use: ReadPreference.primaryPreferred ?
|
||||
this.command(
|
||||
'admin.$cmd',
|
||||
{ endSessions: sessions },
|
||||
{ readPreference: ReadPreference.primaryPreferred },
|
||||
() => {
|
||||
// intentionally ignored, per spec
|
||||
if (typeof callback === 'function') callback();
|
||||
}
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
const RETRYABLE_WIRE_VERSION = 6;
|
||||
|
||||
/**
|
||||
* Determines whether the provided topology supports retryable writes
|
||||
*
|
||||
* @param {Mongos|Replset} topology
|
||||
*/
|
||||
const isRetryableWritesSupported = function(topology) {
|
||||
const maxWireVersion = topology.lastIsMaster().maxWireVersion;
|
||||
if (maxWireVersion < RETRYABLE_WIRE_VERSION) {
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!topology.logicalSessionTimeoutMinutes) {
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
};
|
||||
|
||||
module.exports.SessionMixins = SessionMixins;
|
||||
module.exports.resolveClusterTime = resolveClusterTime;
|
||||
module.exports.inquireServerState = inquireServerState;
|
||||
module.exports.getTopologyType = getTopologyType;
|
||||
module.exports.emitServerDescriptionChanged = emitServerDescriptionChanged;
|
||||
module.exports.emitTopologyDescriptionChanged = emitTopologyDescriptionChanged;
|
||||
module.exports.cloneOptions = cloneOptions;
|
||||
module.exports.createClientInfo = createClientInfo;
|
||||
module.exports.createCompressionInfo = createCompressionInfo;
|
||||
module.exports.clone = clone;
|
||||
module.exports.diff = diff;
|
||||
module.exports.Interval = Interval;
|
||||
module.exports.Timeout = Timeout;
|
||||
module.exports.isRetryableWritesSupported = isRetryableWritesSupported;
|
||||
+134
@@ -0,0 +1,134 @@
|
||||
'use strict';
|
||||
const MongoError = require('./error').MongoError;
|
||||
|
||||
let TxnState;
|
||||
let stateMachine;
|
||||
|
||||
(() => {
|
||||
const NO_TRANSACTION = 'NO_TRANSACTION';
|
||||
const STARTING_TRANSACTION = 'STARTING_TRANSACTION';
|
||||
const TRANSACTION_IN_PROGRESS = 'TRANSACTION_IN_PROGRESS';
|
||||
const TRANSACTION_COMMITTED = 'TRANSACTION_COMMITTED';
|
||||
const TRANSACTION_COMMITTED_EMPTY = 'TRANSACTION_COMMITTED_EMPTY';
|
||||
const TRANSACTION_ABORTED = 'TRANSACTION_ABORTED';
|
||||
|
||||
TxnState = {
|
||||
NO_TRANSACTION,
|
||||
STARTING_TRANSACTION,
|
||||
TRANSACTION_IN_PROGRESS,
|
||||
TRANSACTION_COMMITTED,
|
||||
TRANSACTION_COMMITTED_EMPTY,
|
||||
TRANSACTION_ABORTED
|
||||
};
|
||||
|
||||
stateMachine = {
|
||||
[NO_TRANSACTION]: [NO_TRANSACTION, STARTING_TRANSACTION],
|
||||
[STARTING_TRANSACTION]: [
|
||||
TRANSACTION_IN_PROGRESS,
|
||||
TRANSACTION_COMMITTED,
|
||||
TRANSACTION_COMMITTED_EMPTY,
|
||||
TRANSACTION_ABORTED
|
||||
],
|
||||
[TRANSACTION_IN_PROGRESS]: [
|
||||
TRANSACTION_IN_PROGRESS,
|
||||
TRANSACTION_COMMITTED,
|
||||
TRANSACTION_ABORTED
|
||||
],
|
||||
[TRANSACTION_COMMITTED]: [
|
||||
TRANSACTION_COMMITTED,
|
||||
TRANSACTION_COMMITTED_EMPTY,
|
||||
STARTING_TRANSACTION,
|
||||
NO_TRANSACTION
|
||||
],
|
||||
[TRANSACTION_ABORTED]: [STARTING_TRANSACTION, NO_TRANSACTION],
|
||||
[TRANSACTION_COMMITTED_EMPTY]: [TRANSACTION_COMMITTED_EMPTY, NO_TRANSACTION]
|
||||
};
|
||||
})();
|
||||
|
||||
/**
|
||||
* The MongoDB ReadConcern, which allows for control of the consistency and isolation properties
|
||||
* of the data read from replica sets and replica set shards.
|
||||
* @typedef {Object} ReadConcern
|
||||
* @property {'local'|'available'|'majority'|'linearizable'|'snapshot'} level The readConcern Level
|
||||
* @see https://docs.mongodb.com/manual/reference/read-concern/
|
||||
*/
|
||||
|
||||
/**
|
||||
* A MongoDB WriteConcern, which describes the level of acknowledgement
|
||||
* requested from MongoDB for write operations.
|
||||
* @typedef {Object} WriteConcern
|
||||
* @property {number|'majority'|string} [w=1] requests acknowledgement that the write operation has
|
||||
* propagated to a specified number of mongod hosts
|
||||
* @property {boolean} [j=false] requests acknowledgement from MongoDB that the write operation has
|
||||
* been written to the journal
|
||||
* @property {number} [wtimeout] a time limit, in milliseconds, for the write concern
|
||||
* @see https://docs.mongodb.com/manual/reference/write-concern/
|
||||
*/
|
||||
|
||||
/**
|
||||
* Configuration options for a transaction.
|
||||
* @typedef {Object} TransactionOptions
|
||||
* @property {ReadConcern} [readConcern] A default read concern for commands in this transaction
|
||||
* @property {WriteConcern} [writeConcern] A default writeConcern for commands in this transaction
|
||||
* @property {ReadPreference} [readPreference] A default read preference for commands in this transaction
|
||||
*/
|
||||
|
||||
/**
|
||||
* A class maintaining state related to a server transaction. Internal Only
|
||||
* @ignore
|
||||
*/
|
||||
class Transaction {
|
||||
/**
|
||||
* Create a transaction
|
||||
*
|
||||
* @ignore
|
||||
* @param {TransactionOptions} [options] Optional settings
|
||||
*/
|
||||
constructor(options) {
|
||||
options = options || {};
|
||||
|
||||
this.state = TxnState.NO_TRANSACTION;
|
||||
this.options = {};
|
||||
|
||||
if (options.writeConcern || typeof options.w !== 'undefined') {
|
||||
const w = options.writeConcern ? options.writeConcern.w : options.w;
|
||||
if (w <= 0) {
|
||||
throw new MongoError('Transactions do not support unacknowledged write concern');
|
||||
}
|
||||
|
||||
this.options.writeConcern = options.writeConcern ? options.writeConcern : { w: options.w };
|
||||
}
|
||||
|
||||
if (options.readConcern) this.options.readConcern = options.readConcern;
|
||||
if (options.readPreference) this.options.readPreference = options.readPreference;
|
||||
}
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
* @return Whether this session is presently in a transaction
|
||||
*/
|
||||
get isActive() {
|
||||
return (
|
||||
[TxnState.STARTING_TRANSACTION, TxnState.TRANSACTION_IN_PROGRESS].indexOf(this.state) !== -1
|
||||
);
|
||||
}
|
||||
|
||||
/**
|
||||
* Transition the transaction in the state machine
|
||||
* @ignore
|
||||
* @param {TxnState} state The new state to transition to
|
||||
*/
|
||||
transition(nextState) {
|
||||
const nextStates = stateMachine[this.state];
|
||||
if (nextStates && nextStates.indexOf(nextState) !== -1) {
|
||||
this.state = nextState;
|
||||
return;
|
||||
}
|
||||
|
||||
throw new MongoError(
|
||||
`Attempted illegal state transition from [${this.state}] to [${nextState}]`
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = { TxnState, Transaction };
|
||||
+318
@@ -0,0 +1,318 @@
|
||||
'use strict';
|
||||
const URL = require('url');
|
||||
const qs = require('querystring');
|
||||
const dns = require('dns');
|
||||
const MongoParseError = require('./error').MongoParseError;
|
||||
|
||||
/**
|
||||
* The following regular expression validates a connection string and breaks the
|
||||
* provide string into the following capture groups: [protocol, username, password, hosts]
|
||||
*/
|
||||
const HOSTS_RX = /(mongodb(?:\+srv|)):\/\/(?: (?:[^:]*) (?: : ([^@]*) )? @ )?([^/?]*)(?:\/|)(.*)/;
|
||||
|
||||
/**
|
||||
* Determines whether a provided address matches the provided parent domain in order
|
||||
* to avoid certain attack vectors.
|
||||
*
|
||||
* @param {String} srvAddress The address to check against a domain
|
||||
* @param {String} parentDomain The domain to check the provided address against
|
||||
* @return {Boolean} Whether the provided address matches the parent domain
|
||||
*/
|
||||
function matchesParentDomain(srvAddress, parentDomain) {
|
||||
const regex = /^.*?\./;
|
||||
const srv = `.${srvAddress.replace(regex, '')}`;
|
||||
const parent = `.${parentDomain.replace(regex, '')}`;
|
||||
return srv.endsWith(parent);
|
||||
}
|
||||
|
||||
/**
|
||||
* Lookup an `mongodb+srv` connection string, combine the parts and reparse it as a normal
|
||||
* connection string.
|
||||
*
|
||||
* @param {string} uri The connection string to parse
|
||||
* @param {object} options Optional user provided connection string options
|
||||
* @param {function} callback
|
||||
*/
|
||||
function parseSrvConnectionString(uri, options, callback) {
|
||||
const result = URL.parse(uri, true);
|
||||
|
||||
if (result.hostname.split('.').length < 3) {
|
||||
return callback(new MongoParseError('URI does not have hostname, domain name and tld'));
|
||||
}
|
||||
|
||||
result.domainLength = result.hostname.split('.').length;
|
||||
if (result.pathname && result.pathname.match(',')) {
|
||||
return callback(new MongoParseError('Invalid URI, cannot contain multiple hostnames'));
|
||||
}
|
||||
|
||||
if (result.port) {
|
||||
return callback(new MongoParseError(`Ports not accepted with '${PROTOCOL_MONGODB_SRV}' URIs`));
|
||||
}
|
||||
|
||||
let srvAddress = `_mongodb._tcp.${result.host}`;
|
||||
dns.resolveSrv(srvAddress, (err, addresses) => {
|
||||
if (err) return callback(err);
|
||||
|
||||
if (addresses.length === 0) {
|
||||
return callback(new MongoParseError('No addresses found at host'));
|
||||
}
|
||||
|
||||
for (let i = 0; i < addresses.length; i++) {
|
||||
if (!matchesParentDomain(addresses[i].name, result.hostname, result.domainLength)) {
|
||||
return callback(
|
||||
new MongoParseError('Server record does not share hostname with parent URI')
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
let base = result.auth ? `mongodb://${result.auth}@` : `mongodb://`;
|
||||
let connectionStrings = addresses.map(
|
||||
(address, i) =>
|
||||
i === 0 ? `${base}${address.name}:${address.port}` : `${address.name}:${address.port}`
|
||||
);
|
||||
|
||||
let connectionString = `${connectionStrings.join(',')}/`;
|
||||
let connectionStringOptions = [];
|
||||
|
||||
// Add the default database if needed
|
||||
if (result.path) {
|
||||
let defaultDb = result.path.slice(1);
|
||||
if (defaultDb.indexOf('?') !== -1) {
|
||||
defaultDb = defaultDb.slice(0, defaultDb.indexOf('?'));
|
||||
}
|
||||
|
||||
connectionString += defaultDb;
|
||||
}
|
||||
|
||||
// Default to SSL true
|
||||
if (!options.ssl && (!result.search || result.query['ssl'] == null)) {
|
||||
connectionStringOptions.push('ssl=true');
|
||||
}
|
||||
|
||||
// Keep original uri options
|
||||
if (result.search) {
|
||||
connectionStringOptions.push(result.search.replace('?', ''));
|
||||
}
|
||||
|
||||
dns.resolveTxt(result.host, (err, record) => {
|
||||
if (err) {
|
||||
if (err.code !== 'ENODATA') {
|
||||
return callback(err);
|
||||
}
|
||||
record = null;
|
||||
}
|
||||
|
||||
if (record) {
|
||||
if (record.length > 1) {
|
||||
return callback(new MongoParseError('Multiple text records not allowed'));
|
||||
}
|
||||
|
||||
record = record[0];
|
||||
record = record.length > 1 ? record.join('') : record[0];
|
||||
if (record.indexOf('authSource') === -1 && record.indexOf('replicaSet') === -1) {
|
||||
return callback(
|
||||
new MongoParseError('Text record must only set `authSource` or `replicaSet`')
|
||||
);
|
||||
}
|
||||
|
||||
connectionStringOptions.push(record);
|
||||
}
|
||||
|
||||
// Add any options to the connection string
|
||||
if (connectionStringOptions.length) {
|
||||
connectionString += `?${connectionStringOptions.join('&')}`;
|
||||
}
|
||||
|
||||
parseConnectionString(connectionString, callback);
|
||||
});
|
||||
});
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a query string item according to the connection string spec
|
||||
*
|
||||
* @param {Array|String} value The value to parse
|
||||
* @return {Array|Object|String} The parsed value
|
||||
*/
|
||||
function parseQueryStringItemValue(value) {
|
||||
if (Array.isArray(value)) {
|
||||
// deduplicate and simplify arrays
|
||||
value = value.filter((v, idx) => value.indexOf(v) === idx);
|
||||
if (value.length === 1) value = value[0];
|
||||
} else if (value.indexOf(':') > 0) {
|
||||
value = value.split(',').reduce((result, pair) => {
|
||||
const parts = pair.split(':');
|
||||
result[parts[0]] = parseQueryStringItemValue(parts[1]);
|
||||
return result;
|
||||
}, {});
|
||||
} else if (value.indexOf(',') > 0) {
|
||||
value = value.split(',').map(v => {
|
||||
return parseQueryStringItemValue(v);
|
||||
});
|
||||
} else if (value.toLowerCase() === 'true' || value.toLowerCase() === 'false') {
|
||||
value = value.toLowerCase() === 'true';
|
||||
} else if (!Number.isNaN(value)) {
|
||||
const numericValue = parseFloat(value);
|
||||
if (!Number.isNaN(numericValue)) {
|
||||
value = parseFloat(value);
|
||||
}
|
||||
}
|
||||
|
||||
return value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Parses a query string according the connection string spec.
|
||||
*
|
||||
* @param {String} query The query string to parse
|
||||
* @return {Object|Error} The parsed query string as an object, or an error if one was encountered
|
||||
*/
|
||||
function parseQueryString(query) {
|
||||
const result = {};
|
||||
let parsedQueryString = qs.parse(query);
|
||||
|
||||
for (const key in parsedQueryString) {
|
||||
const value = parsedQueryString[key];
|
||||
if (value === '' || value == null) {
|
||||
return new MongoParseError('Incomplete key value pair for option');
|
||||
}
|
||||
|
||||
result[key.toLowerCase()] = parseQueryStringItemValue(value);
|
||||
}
|
||||
|
||||
// special cases for known deprecated options
|
||||
if (result.wtimeout && result.wtimeoutms) {
|
||||
delete result.wtimeout;
|
||||
console.warn('Unsupported option `wtimeout` specified');
|
||||
}
|
||||
|
||||
return Object.keys(result).length ? result : null;
|
||||
}
|
||||
|
||||
const PROTOCOL_MONGODB = 'mongodb';
|
||||
const PROTOCOL_MONGODB_SRV = 'mongodb+srv';
|
||||
const SUPPORTED_PROTOCOLS = [PROTOCOL_MONGODB, PROTOCOL_MONGODB_SRV];
|
||||
|
||||
/**
|
||||
* Parses a MongoDB connection string
|
||||
*
|
||||
* @param {*} uri the MongoDB connection string to parse
|
||||
* @param {object} [options] Optional settings.
|
||||
* @param {parseCallback} callback
|
||||
*/
|
||||
function parseConnectionString(uri, options, callback) {
|
||||
if (typeof options === 'function') (callback = options), (options = {});
|
||||
options = options || {};
|
||||
|
||||
// Check for bad uris before we parse
|
||||
try {
|
||||
URL.parse(uri);
|
||||
} catch (e) {
|
||||
return callback(new MongoParseError('URI malformed, cannot be parsed'));
|
||||
}
|
||||
|
||||
const cap = uri.match(HOSTS_RX);
|
||||
if (!cap) {
|
||||
return callback(new MongoParseError('Invalid connection string'));
|
||||
}
|
||||
|
||||
const protocol = cap[1];
|
||||
if (SUPPORTED_PROTOCOLS.indexOf(protocol) === -1) {
|
||||
return callback(new MongoParseError('Invalid protocol provided'));
|
||||
}
|
||||
|
||||
if (protocol === PROTOCOL_MONGODB_SRV) {
|
||||
return parseSrvConnectionString(uri, options, callback);
|
||||
}
|
||||
|
||||
const dbAndQuery = cap[4].split('?');
|
||||
const db = dbAndQuery.length > 0 ? dbAndQuery[0] : null;
|
||||
const query = dbAndQuery.length > 1 ? dbAndQuery[1] : null;
|
||||
let parsedOptions = parseQueryString(query);
|
||||
if (parsedOptions instanceof MongoParseError) {
|
||||
return callback(parsedOptions);
|
||||
}
|
||||
|
||||
parsedOptions = Object.assign({}, parsedOptions, options);
|
||||
const auth = { username: null, password: null, db: db && db !== '' ? qs.unescape(db) : null };
|
||||
if (cap[4].split('?')[0].indexOf('@') !== -1) {
|
||||
return callback(new MongoParseError('Unescaped slash in userinfo section'));
|
||||
}
|
||||
|
||||
const authorityParts = cap[3].split('@');
|
||||
if (authorityParts.length > 2) {
|
||||
return callback(new MongoParseError('Unescaped at-sign in authority section'));
|
||||
}
|
||||
|
||||
if (authorityParts.length > 1) {
|
||||
const authParts = authorityParts.shift().split(':');
|
||||
if (authParts.length > 2) {
|
||||
return callback(new MongoParseError('Unescaped colon in authority section'));
|
||||
}
|
||||
|
||||
auth.username = qs.unescape(authParts[0]);
|
||||
auth.password = authParts[1] ? qs.unescape(authParts[1]) : null;
|
||||
}
|
||||
|
||||
let hostParsingError = null;
|
||||
const hosts = authorityParts
|
||||
.shift()
|
||||
.split(',')
|
||||
.map(host => {
|
||||
let parsedHost = URL.parse(`mongodb://${host}`);
|
||||
if (parsedHost.path === '/:') {
|
||||
hostParsingError = new MongoParseError('Double colon in host identifier');
|
||||
return null;
|
||||
}
|
||||
|
||||
// heuristically determine if we're working with a domain socket
|
||||
if (host.match(/\.sock/)) {
|
||||
parsedHost.hostname = qs.unescape(host);
|
||||
parsedHost.port = null;
|
||||
}
|
||||
|
||||
if (Number.isNaN(parsedHost.port)) {
|
||||
hostParsingError = new MongoParseError('Invalid port (non-numeric string)');
|
||||
return;
|
||||
}
|
||||
|
||||
const result = {
|
||||
host: parsedHost.hostname,
|
||||
port: parsedHost.port ? parseInt(parsedHost.port) : 27017
|
||||
};
|
||||
|
||||
if (result.port === 0) {
|
||||
hostParsingError = new MongoParseError('Invalid port (zero) with hostname');
|
||||
return;
|
||||
}
|
||||
|
||||
if (result.port > 65535) {
|
||||
hostParsingError = new MongoParseError('Invalid port (larger than 65535) with hostname');
|
||||
return;
|
||||
}
|
||||
|
||||
if (result.port < 0) {
|
||||
hostParsingError = new MongoParseError('Invalid port (negative number)');
|
||||
return;
|
||||
}
|
||||
|
||||
return result;
|
||||
})
|
||||
.filter(host => !!host);
|
||||
|
||||
if (hostParsingError) {
|
||||
return callback(hostParsingError);
|
||||
}
|
||||
|
||||
if (hosts.length === 0 || hosts[0].host === '' || hosts[0].host === null) {
|
||||
return callback(new MongoParseError('No hostname or hostnames provided in connection string'));
|
||||
}
|
||||
|
||||
callback(null, {
|
||||
hosts: hosts,
|
||||
auth: auth.db || auth.username ? auth : null,
|
||||
options: Object.keys(parsedOptions).length ? parsedOptions : null
|
||||
});
|
||||
}
|
||||
|
||||
module.exports = parseConnectionString;
|
||||
+95
@@ -0,0 +1,95 @@
|
||||
'use strict';
|
||||
|
||||
const crypto = require('crypto');
|
||||
const requireOptional = require('require_optional');
|
||||
|
||||
/**
|
||||
* Generate a UUIDv4
|
||||
*/
|
||||
const uuidV4 = () => {
|
||||
const result = crypto.randomBytes(16);
|
||||
result[6] = (result[6] & 0x0f) | 0x40;
|
||||
result[8] = (result[8] & 0x3f) | 0x80;
|
||||
return result;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the duration calculated from two high resolution timers in milliseconds
|
||||
*
|
||||
* @param {Object} started A high resolution timestamp created from `process.hrtime()`
|
||||
* @returns {Number} The duration in milliseconds
|
||||
*/
|
||||
const calculateDurationInMs = started => {
|
||||
const hrtime = process.hrtime(started);
|
||||
return (hrtime[0] * 1e9 + hrtime[1]) / 1e6;
|
||||
};
|
||||
|
||||
/**
|
||||
* Relays events for a given listener and emitter
|
||||
*
|
||||
* @param {EventEmitter} listener the EventEmitter to listen to the events from
|
||||
* @param {EventEmitter} emitter the EventEmitter to relay the events to
|
||||
*/
|
||||
function relayEvents(listener, emitter, events) {
|
||||
events.forEach(eventName => listener.on(eventName, event => emitter.emit(eventName, event)));
|
||||
}
|
||||
|
||||
// Grab Kerberos values if they exist, otherwise set them to null
|
||||
let Kerberos = null;
|
||||
let MongoAuthProcess = null;
|
||||
|
||||
try {
|
||||
const kerberos = requireOptional('kerberos');
|
||||
if (kerberos) {
|
||||
Kerberos = kerberos.Kerberos;
|
||||
MongoAuthProcess = kerberos.processes.MongoAuthProcess;
|
||||
}
|
||||
} catch (err) {
|
||||
console.warn(err.message);
|
||||
}
|
||||
|
||||
// Throw an error if an attempt to use EJSON is made when it is not installed
|
||||
const noEJSONError = function() {
|
||||
throw new Error('The `mongodb-extjson` package was not found. Please install it and try again.');
|
||||
};
|
||||
|
||||
// Facilitate loading EJSON optionally
|
||||
const retrieveEJSON = function() {
|
||||
let EJSON = null;
|
||||
try {
|
||||
EJSON = requireOptional('mongodb-extjson');
|
||||
} catch (error) {} // eslint-disable-line
|
||||
if (!EJSON) {
|
||||
EJSON = {
|
||||
parse: noEJSONError,
|
||||
deserialize: noEJSONError,
|
||||
serialize: noEJSONError,
|
||||
stringify: noEJSONError,
|
||||
setBSONModule: noEJSONError,
|
||||
BSON: noEJSONError
|
||||
};
|
||||
}
|
||||
return EJSON;
|
||||
};
|
||||
|
||||
/*
|
||||
* Checks that collation is supported by server.
|
||||
*
|
||||
* @param {Server} [server] to check against
|
||||
* @param {object} [cmd] object where collation may be specified
|
||||
* @param {function} [callback] callback function
|
||||
* @return true if server does not support collation
|
||||
*/
|
||||
function collationNotSupported(server, cmd) {
|
||||
return cmd && cmd.collation && server.ismaster && server.ismaster.maxWireVersion < 5;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
uuidV4,
|
||||
calculateDurationInMs,
|
||||
relayEvents,
|
||||
Kerberos,
|
||||
MongoAuthProcess,
|
||||
collationNotSupported,
|
||||
retrieveEJSON
|
||||
};
|
||||
+368
@@ -0,0 +1,368 @@
|
||||
'use strict';
|
||||
|
||||
var copy = require('../connection/utils').copy,
|
||||
retrieveBSON = require('../connection/utils').retrieveBSON,
|
||||
KillCursor = require('../connection/commands').KillCursor,
|
||||
GetMore = require('../connection/commands').GetMore,
|
||||
Query = require('../connection/commands').Query,
|
||||
f = require('util').format,
|
||||
MongoError = require('../error').MongoError,
|
||||
getReadPreference = require('./shared').getReadPreference;
|
||||
|
||||
var BSON = retrieveBSON(),
|
||||
Long = BSON.Long;
|
||||
|
||||
var WireProtocol = function() {};
|
||||
|
||||
//
|
||||
// Execute a write operation
|
||||
var executeWrite = function(pool, bson, type, opsField, ns, ops, options, callback) {
|
||||
if (ops.length === 0) throw new MongoError('insert must contain at least one document');
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
options = options || {};
|
||||
}
|
||||
|
||||
// Split the ns up to get db and collection
|
||||
var p = ns.split('.');
|
||||
var d = p.shift();
|
||||
// Options
|
||||
var ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
|
||||
var writeConcern = options.writeConcern;
|
||||
|
||||
// return skeleton
|
||||
var writeCommand = {};
|
||||
writeCommand[type] = p.join('.');
|
||||
writeCommand[opsField] = ops;
|
||||
writeCommand.ordered = ordered;
|
||||
|
||||
// Did we specify a write concern
|
||||
if (writeConcern && Object.keys(writeConcern).length > 0) {
|
||||
writeCommand.writeConcern = writeConcern;
|
||||
}
|
||||
|
||||
// Do we have bypassDocumentValidation set, then enable it on the write command
|
||||
if (options.bypassDocumentValidation === true) {
|
||||
writeCommand.bypassDocumentValidation = options.bypassDocumentValidation;
|
||||
}
|
||||
|
||||
// Options object
|
||||
var opts = { command: true };
|
||||
if (typeof options.session !== 'undefined') opts.session = options.session;
|
||||
var queryOptions = { checkKeys: false, numberToSkip: 0, numberToReturn: 1 };
|
||||
if (type === 'insert') queryOptions.checkKeys = true;
|
||||
if (typeof options.checkKeys === 'boolean') queryOptions.checkKeys = options.checkKeys;
|
||||
// Ensure we support serialization of functions
|
||||
if (options.serializeFunctions) queryOptions.serializeFunctions = options.serializeFunctions;
|
||||
// Do not serialize the undefined fields
|
||||
if (options.ignoreUndefined) queryOptions.ignoreUndefined = options.ignoreUndefined;
|
||||
|
||||
try {
|
||||
// Create write command
|
||||
var cmd = new Query(bson, f('%s.$cmd', d), writeCommand, queryOptions);
|
||||
// Execute command
|
||||
pool.write(cmd, opts, callback);
|
||||
} catch (err) {
|
||||
callback(err);
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// Needs to support legacy mass insert as well as ordered/unordered legacy
|
||||
// emulation
|
||||
//
|
||||
WireProtocol.prototype.insert = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'insert', 'documents', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.update = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'update', 'updates', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.remove = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'delete', 'deletes', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.killCursor = function(bson, ns, cursorState, pool, callback) {
|
||||
var cursorId = cursorState.cursorId;
|
||||
// Create a kill cursor command
|
||||
var killCursor = new KillCursor(bson, ns, [cursorId]);
|
||||
|
||||
// Build killCursor options
|
||||
const options = {
|
||||
immediateRelease: true,
|
||||
noResponse: true
|
||||
};
|
||||
|
||||
if (typeof cursorState.session === 'object') {
|
||||
options.session = cursorState.session;
|
||||
}
|
||||
|
||||
// Execute the kill cursor command
|
||||
if (pool && pool.isConnected()) {
|
||||
try {
|
||||
pool.write(killCursor, options, callback);
|
||||
} catch (err) {
|
||||
if (typeof callback === 'function') {
|
||||
callback(err, null);
|
||||
} else {
|
||||
console.warn(err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
WireProtocol.prototype.getMore = function(
|
||||
bson,
|
||||
ns,
|
||||
cursorState,
|
||||
batchSize,
|
||||
raw,
|
||||
connection,
|
||||
options,
|
||||
callback
|
||||
) {
|
||||
// Create getMore command
|
||||
var getMore = new GetMore(bson, ns, cursorState.cursorId, { numberToReturn: batchSize });
|
||||
|
||||
// Query callback
|
||||
var queryCallback = function(err, result) {
|
||||
if (err) return callback(err);
|
||||
// Get the raw message
|
||||
var r = result.message;
|
||||
|
||||
// If we have a timed out query or a cursor that was killed
|
||||
if ((r.responseFlags & (1 << 0)) !== 0) {
|
||||
return callback(new MongoError('cursor does not exist, was killed or timed out'), null);
|
||||
}
|
||||
|
||||
// Ensure we have a Long valie cursor id
|
||||
var cursorId = typeof r.cursorId === 'number' ? Long.fromNumber(r.cursorId) : r.cursorId;
|
||||
|
||||
// Set all the values
|
||||
cursorState.documents = r.documents;
|
||||
cursorState.cursorId = cursorId;
|
||||
|
||||
// Return
|
||||
callback(null, null, r.connection);
|
||||
};
|
||||
|
||||
// Contains any query options
|
||||
var queryOptions = {};
|
||||
|
||||
// If we have a raw query decorate the function
|
||||
if (raw) {
|
||||
queryOptions.raw = raw;
|
||||
}
|
||||
|
||||
// Check if we need to promote longs
|
||||
if (typeof cursorState.promoteLongs === 'boolean') {
|
||||
queryOptions.promoteLongs = cursorState.promoteLongs;
|
||||
}
|
||||
|
||||
if (typeof cursorState.promoteValues === 'boolean') {
|
||||
queryOptions.promoteValues = cursorState.promoteValues;
|
||||
}
|
||||
|
||||
if (typeof cursorState.promoteBuffers === 'boolean') {
|
||||
queryOptions.promoteBuffers = cursorState.promoteBuffers;
|
||||
}
|
||||
|
||||
if (typeof cursorState.session === 'object') {
|
||||
queryOptions.session = cursorState.session;
|
||||
}
|
||||
|
||||
// Write out the getMore command
|
||||
connection.write(getMore, queryOptions, queryCallback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.command = function(bson, ns, cmd, cursorState, topology, options) {
|
||||
// Establish type of command
|
||||
if (cmd.find) {
|
||||
return setupClassicFind(bson, ns, cmd, cursorState, topology, options);
|
||||
} else if (cursorState.cursorId != null) {
|
||||
return;
|
||||
} else if (cmd) {
|
||||
return setupCommand(bson, ns, cmd, cursorState, topology, options);
|
||||
} else {
|
||||
throw new MongoError(f('command %s does not return a cursor', JSON.stringify(cmd)));
|
||||
}
|
||||
};
|
||||
|
||||
//
|
||||
// Execute a find command
|
||||
var setupClassicFind = function(bson, ns, cmd, cursorState, topology, options) {
|
||||
// Ensure we have at least some options
|
||||
options = options || {};
|
||||
// Get the readPreference
|
||||
var readPreference = getReadPreference(cmd, options);
|
||||
// Set the optional batchSize
|
||||
cursorState.batchSize = cmd.batchSize || cursorState.batchSize;
|
||||
var numberToReturn = 0;
|
||||
|
||||
// Unpack the limit and batchSize values
|
||||
if (cursorState.limit === 0) {
|
||||
numberToReturn = cursorState.batchSize;
|
||||
} else if (
|
||||
cursorState.limit < 0 ||
|
||||
cursorState.limit < cursorState.batchSize ||
|
||||
(cursorState.limit > 0 && cursorState.batchSize === 0)
|
||||
) {
|
||||
numberToReturn = cursorState.limit;
|
||||
} else {
|
||||
numberToReturn = cursorState.batchSize;
|
||||
}
|
||||
|
||||
var numberToSkip = cursorState.skip || 0;
|
||||
// Build actual find command
|
||||
var findCmd = {};
|
||||
|
||||
// We have a Mongos topology, check if we need to add a readPreference
|
||||
if (topology.type === 'mongos' && readPreference) {
|
||||
findCmd['$readPreference'] = readPreference.toJSON();
|
||||
}
|
||||
|
||||
// Add special modifiers to the query
|
||||
if (cmd.sort) findCmd['$orderby'] = cmd.sort;
|
||||
if (cmd.hint) findCmd['$hint'] = cmd.hint;
|
||||
if (cmd.snapshot) findCmd['$snapshot'] = cmd.snapshot;
|
||||
if (typeof cmd.returnKey !== 'undefined') findCmd['$returnKey'] = cmd.returnKey;
|
||||
if (cmd.maxScan) findCmd['$maxScan'] = cmd.maxScan;
|
||||
if (cmd.min) findCmd['$min'] = cmd.min;
|
||||
if (cmd.max) findCmd['$max'] = cmd.max;
|
||||
if (typeof cmd.showDiskLoc !== 'undefined') findCmd['$showDiskLoc'] = cmd.showDiskLoc;
|
||||
if (cmd.comment) findCmd['$comment'] = cmd.comment;
|
||||
if (cmd.maxTimeMS) findCmd['$maxTimeMS'] = cmd.maxTimeMS;
|
||||
|
||||
if (cmd.explain) {
|
||||
// nToReturn must be 0 (match all) or negative (match N and close cursor)
|
||||
// nToReturn > 0 will give explain results equivalent to limit(0)
|
||||
numberToReturn = -Math.abs(cmd.limit || 0);
|
||||
findCmd['$explain'] = true;
|
||||
}
|
||||
|
||||
// Add the query
|
||||
findCmd['$query'] = cmd.query;
|
||||
|
||||
// Throw on majority readConcern passed in
|
||||
if (cmd.readConcern && cmd.readConcern.level !== 'local') {
|
||||
throw new MongoError(
|
||||
f('server find command does not support a readConcern level of %s', cmd.readConcern.level)
|
||||
);
|
||||
}
|
||||
|
||||
// Remove readConcern, ensure no failing commands
|
||||
if (cmd.readConcern) {
|
||||
cmd = copy(cmd);
|
||||
delete cmd['readConcern'];
|
||||
}
|
||||
|
||||
// Serialize functions
|
||||
var serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
var ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
|
||||
|
||||
// Build Query object
|
||||
var query = new Query(bson, ns, findCmd, {
|
||||
numberToSkip: numberToSkip,
|
||||
numberToReturn: numberToReturn,
|
||||
pre32Limit: typeof cmd.limit !== 'undefined' ? cmd.limit : undefined,
|
||||
checkKeys: false,
|
||||
returnFieldSelector: cmd.fields,
|
||||
serializeFunctions: serializeFunctions,
|
||||
ignoreUndefined: ignoreUndefined
|
||||
});
|
||||
|
||||
// Set query flags
|
||||
query.slaveOk = readPreference.slaveOk();
|
||||
|
||||
// Set up the option bits for wire protocol
|
||||
if (typeof cmd.tailable === 'boolean') {
|
||||
query.tailable = cmd.tailable;
|
||||
}
|
||||
|
||||
if (typeof cmd.oplogReplay === 'boolean') {
|
||||
query.oplogReplay = cmd.oplogReplay;
|
||||
}
|
||||
|
||||
if (typeof cmd.noCursorTimeout === 'boolean') {
|
||||
query.noCursorTimeout = cmd.noCursorTimeout;
|
||||
}
|
||||
|
||||
if (typeof cmd.awaitData === 'boolean') {
|
||||
query.awaitData = cmd.awaitData;
|
||||
}
|
||||
|
||||
if (typeof cmd.partial === 'boolean') {
|
||||
query.partial = cmd.partial;
|
||||
}
|
||||
|
||||
// Return the query
|
||||
return query;
|
||||
};
|
||||
|
||||
//
|
||||
// Set up a command cursor
|
||||
var setupCommand = function(bson, ns, cmd, cursorState, topology, options) {
|
||||
// Set empty options object
|
||||
options = options || {};
|
||||
// Get the readPreference
|
||||
var readPreference = getReadPreference(cmd, options);
|
||||
|
||||
// Final query
|
||||
var finalCmd = {};
|
||||
for (var name in cmd) {
|
||||
finalCmd[name] = cmd[name];
|
||||
}
|
||||
|
||||
// Build command namespace
|
||||
var parts = ns.split(/\./);
|
||||
|
||||
// Serialize functions
|
||||
var serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
|
||||
var ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
|
||||
|
||||
// Throw on majority readConcern passed in
|
||||
if (cmd.readConcern && cmd.readConcern.level !== 'local') {
|
||||
throw new MongoError(
|
||||
f(
|
||||
'server %s command does not support a readConcern level of %s',
|
||||
JSON.stringify(cmd),
|
||||
cmd.readConcern.level
|
||||
)
|
||||
);
|
||||
}
|
||||
|
||||
// Remove readConcern, ensure no failing commands
|
||||
if (cmd.readConcern) delete cmd['readConcern'];
|
||||
|
||||
// We have a Mongos topology, check if we need to add a readPreference
|
||||
if (topology.type === 'mongos' && readPreference && readPreference.preference !== 'primary') {
|
||||
finalCmd = {
|
||||
$query: finalCmd,
|
||||
$readPreference: readPreference.toJSON()
|
||||
};
|
||||
}
|
||||
|
||||
// Build Query object
|
||||
var query = new Query(bson, f('%s.$cmd', parts.shift()), finalCmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: -1,
|
||||
checkKeys: false,
|
||||
serializeFunctions: serializeFunctions,
|
||||
ignoreUndefined: ignoreUndefined
|
||||
});
|
||||
|
||||
// Set query flags
|
||||
query.slaveOk = readPreference.slaveOk();
|
||||
|
||||
// Return the query
|
||||
return query;
|
||||
};
|
||||
|
||||
module.exports = WireProtocol;
|
||||
+682
@@ -0,0 +1,682 @@
|
||||
'use strict';
|
||||
|
||||
const Query = require('../connection/commands').Query;
|
||||
const retrieveBSON = require('../connection/utils').retrieveBSON;
|
||||
const MongoError = require('../error').MongoError;
|
||||
const MongoNetworkError = require('../error').MongoNetworkError;
|
||||
const getReadPreference = require('./shared').getReadPreference;
|
||||
const BSON = retrieveBSON();
|
||||
const Long = BSON.Long;
|
||||
const ReadPreference = require('../topologies/read_preference');
|
||||
const TxnState = require('../transactions').TxnState;
|
||||
|
||||
const WireProtocol = function() {};
|
||||
|
||||
function isTransactionCommand(command) {
|
||||
return !!(command.commitTransaction || command.abortTransaction);
|
||||
}
|
||||
|
||||
/**
|
||||
* Optionally decorate a command with sessions specific keys
|
||||
*
|
||||
* @param {Object} command the command to decorate
|
||||
* @param {ClientSession} session the session tracking transaction state
|
||||
* @param {Object} [options] Optional settings passed to calling operation
|
||||
* @param {Function} [callback] Optional callback passed from calling operation
|
||||
* @return {MongoError|null} An error, if some error condition was met
|
||||
*/
|
||||
function decorateWithSessionsData(command, session, options) {
|
||||
if (!session) {
|
||||
return;
|
||||
}
|
||||
|
||||
// first apply non-transaction-specific sessions data
|
||||
const serverSession = session.serverSession;
|
||||
const inTransaction = session.inTransaction() || isTransactionCommand(command);
|
||||
const isRetryableWrite = options.willRetryWrite;
|
||||
|
||||
if (serverSession.txnNumber && (isRetryableWrite || inTransaction)) {
|
||||
command.txnNumber = BSON.Long.fromNumber(serverSession.txnNumber);
|
||||
}
|
||||
|
||||
// now attempt to apply transaction-specific sessions data
|
||||
if (!inTransaction) {
|
||||
if (session.transaction.state !== TxnState.NO_TRANSACTION) {
|
||||
session.transaction.transition(TxnState.NO_TRANSACTION);
|
||||
}
|
||||
|
||||
// for causal consistency
|
||||
if (session.supports.causalConsistency && session.operationTime) {
|
||||
command.readConcern = command.readConcern || {};
|
||||
Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
if (options.readPreference && !options.readPreference.equals(ReadPreference.primary)) {
|
||||
return new MongoError(
|
||||
`Read preference in a transaction must be primary, not: ${options.readPreference.mode}`
|
||||
);
|
||||
}
|
||||
|
||||
// `autocommit` must always be false to differentiate from retryable writes
|
||||
command.autocommit = false;
|
||||
|
||||
if (session.transaction.state === TxnState.STARTING_TRANSACTION) {
|
||||
session.transaction.transition(TxnState.TRANSACTION_IN_PROGRESS);
|
||||
command.startTransaction = true;
|
||||
|
||||
const readConcern =
|
||||
session.transaction.options.readConcern || session.clientOptions.readConcern;
|
||||
if (readConcern) {
|
||||
command.readConcern = readConcern;
|
||||
}
|
||||
|
||||
if (session.supports.causalConsistency && session.operationTime) {
|
||||
command.readConcern = command.readConcern || {};
|
||||
Object.assign(command.readConcern, { afterClusterTime: session.operationTime });
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Execute a write operation
|
||||
function executeWrite(pool, bson, type, opsField, ns, ops, options, callback) {
|
||||
if (ops.length === 0) throw new MongoError('insert must contain at least one document');
|
||||
if (typeof options === 'function') {
|
||||
callback = options;
|
||||
options = {};
|
||||
options = options || {};
|
||||
}
|
||||
|
||||
// Split the ns up to get db and collection
|
||||
const p = ns.split('.');
|
||||
const d = p.shift();
|
||||
// Options
|
||||
const ordered = typeof options.ordered === 'boolean' ? options.ordered : true;
|
||||
const writeConcern = options.writeConcern;
|
||||
|
||||
// return skeleton
|
||||
const writeCommand = {};
|
||||
writeCommand[type] = p.join('.');
|
||||
writeCommand[opsField] = ops;
|
||||
writeCommand.ordered = ordered;
|
||||
|
||||
// Did we specify a write concern
|
||||
if (writeConcern && Object.keys(writeConcern).length > 0) {
|
||||
writeCommand.writeConcern = writeConcern;
|
||||
}
|
||||
|
||||
// If we have collation passed in
|
||||
if (options.collation) {
|
||||
for (let i = 0; i < writeCommand[opsField].length; i++) {
|
||||
if (!writeCommand[opsField][i].collation) {
|
||||
writeCommand[opsField][i].collation = options.collation;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Do we have bypassDocumentValidation set, then enable it on the write command
|
||||
if (options.bypassDocumentValidation === true) {
|
||||
writeCommand.bypassDocumentValidation = options.bypassDocumentValidation;
|
||||
}
|
||||
|
||||
// optionally decorate command with transactions data
|
||||
const err = decorateWithSessionsData(writeCommand, options.session, options, callback);
|
||||
if (err) {
|
||||
return callback(err, null);
|
||||
}
|
||||
|
||||
// Options object
|
||||
const opts = { command: true };
|
||||
if (typeof options.session !== 'undefined') opts.session = options.session;
|
||||
const queryOptions = { checkKeys: false, numberToSkip: 0, numberToReturn: 1 };
|
||||
if (type === 'insert') queryOptions.checkKeys = true;
|
||||
if (typeof options.checkKeys === 'boolean') queryOptions.checkKeys = options.checkKeys;
|
||||
|
||||
// Ensure we support serialization of functions
|
||||
if (options.serializeFunctions) queryOptions.serializeFunctions = options.serializeFunctions;
|
||||
// Do not serialize the undefined fields
|
||||
if (options.ignoreUndefined) queryOptions.ignoreUndefined = options.ignoreUndefined;
|
||||
|
||||
try {
|
||||
// Create write command
|
||||
const cmd = new Query(bson, `${d}.$cmd`, writeCommand, queryOptions);
|
||||
// Execute command
|
||||
pool.write(cmd, opts, callback);
|
||||
} catch (err) {
|
||||
callback(err);
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// Needs to support legacy mass insert as well as ordered/unordered legacy
|
||||
// emulation
|
||||
//
|
||||
WireProtocol.prototype.insert = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'insert', 'documents', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.update = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'update', 'updates', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.remove = function(pool, ns, bson, ops, options, callback) {
|
||||
executeWrite(pool, bson, 'delete', 'deletes', ns, ops, options, callback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.killCursor = function(bson, ns, cursorState, pool, callback) {
|
||||
// Build command namespace
|
||||
const parts = ns.split(/\./);
|
||||
// Command namespace
|
||||
const commandns = `${parts.shift()}.$cmd`;
|
||||
const cursorId = cursorState.cursorId;
|
||||
// Create killCursor command
|
||||
const killcursorCmd = {
|
||||
killCursors: parts.join('.'),
|
||||
cursors: [cursorId]
|
||||
};
|
||||
|
||||
// Build Query object
|
||||
const query = new Query(bson, commandns, killcursorCmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: -1,
|
||||
checkKeys: false,
|
||||
returnFieldSelector: null
|
||||
});
|
||||
|
||||
// Kill cursor callback
|
||||
function killCursorCallback(err, result) {
|
||||
if (err) {
|
||||
if (typeof callback !== 'function') return;
|
||||
return callback(err);
|
||||
}
|
||||
|
||||
// Result
|
||||
const r = result.message;
|
||||
// If we have a timed out query or a cursor that was killed
|
||||
if ((r.responseFlags & (1 << 0)) !== 0) {
|
||||
if (typeof callback !== 'function') return;
|
||||
return callback(new MongoNetworkError('cursor killed or timed out'), null);
|
||||
}
|
||||
|
||||
if (!Array.isArray(r.documents) || r.documents.length === 0) {
|
||||
if (typeof callback !== 'function') return;
|
||||
return callback(
|
||||
new MongoError(`invalid killCursors result returned for cursor id ${cursorId}`)
|
||||
);
|
||||
}
|
||||
|
||||
// Return the result
|
||||
if (typeof callback === 'function') {
|
||||
callback(null, r.documents[0]);
|
||||
}
|
||||
}
|
||||
|
||||
const options = { command: true };
|
||||
if (typeof cursorState.session === 'object') {
|
||||
options.session = cursorState.session;
|
||||
}
|
||||
|
||||
// Execute the kill cursor command
|
||||
if (pool && pool.isConnected()) {
|
||||
try {
|
||||
pool.write(query, options, killCursorCallback);
|
||||
} catch (err) {
|
||||
killCursorCallback(err, null);
|
||||
}
|
||||
|
||||
return;
|
||||
}
|
||||
|
||||
// Callback
|
||||
if (typeof callback === 'function') callback(null, null);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.getMore = function(
|
||||
bson,
|
||||
ns,
|
||||
cursorState,
|
||||
batchSize,
|
||||
raw,
|
||||
connection,
|
||||
options,
|
||||
callback
|
||||
) {
|
||||
options = options || {};
|
||||
// Build command namespace
|
||||
const parts = ns.split(/\./);
|
||||
// Command namespace
|
||||
const commandns = `${parts.shift()}.$cmd`;
|
||||
|
||||
// Create getMore command
|
||||
const getMoreCmd = {
|
||||
getMore: cursorState.cursorId,
|
||||
collection: parts.join('.'),
|
||||
batchSize: Math.abs(batchSize)
|
||||
};
|
||||
|
||||
// optionally decorate command with transactions data
|
||||
const err = decorateWithSessionsData(getMoreCmd, options.session, options, callback);
|
||||
if (err) {
|
||||
return callback(err, null);
|
||||
}
|
||||
|
||||
if (cursorState.cmd.tailable && typeof cursorState.cmd.maxAwaitTimeMS === 'number') {
|
||||
getMoreCmd.maxTimeMS = cursorState.cmd.maxAwaitTimeMS;
|
||||
}
|
||||
|
||||
// Build Query object
|
||||
const query = new Query(bson, commandns, getMoreCmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: -1,
|
||||
checkKeys: false,
|
||||
returnFieldSelector: null
|
||||
});
|
||||
|
||||
// Query callback
|
||||
function queryCallback(err, result) {
|
||||
if (err) return callback(err);
|
||||
// Get the raw message
|
||||
const r = result.message;
|
||||
|
||||
// If we have a timed out query or a cursor that was killed
|
||||
if ((r.responseFlags & (1 << 0)) !== 0) {
|
||||
return callback(new MongoNetworkError('cursor killed or timed out'), null);
|
||||
}
|
||||
|
||||
// Raw, return all the extracted documents
|
||||
if (raw) {
|
||||
cursorState.documents = r.documents;
|
||||
cursorState.cursorId = r.cursorId;
|
||||
return callback(null, r.documents);
|
||||
}
|
||||
|
||||
// We have an error detected
|
||||
if (r.documents[0].ok === 0) {
|
||||
return callback(new MongoError(r.documents[0]));
|
||||
}
|
||||
|
||||
// Ensure we have a Long valid cursor id
|
||||
const cursorId =
|
||||
typeof r.documents[0].cursor.id === 'number'
|
||||
? Long.fromNumber(r.documents[0].cursor.id)
|
||||
: r.documents[0].cursor.id;
|
||||
|
||||
// Set all the values
|
||||
cursorState.documents = r.documents[0].cursor.nextBatch;
|
||||
cursorState.cursorId = cursorId;
|
||||
|
||||
// Return the result
|
||||
callback(null, r.documents[0], r.connection);
|
||||
}
|
||||
|
||||
// Query options
|
||||
const queryOptions = { command: true };
|
||||
|
||||
// If we have a raw query decorate the function
|
||||
if (raw) {
|
||||
queryOptions.raw = raw;
|
||||
}
|
||||
|
||||
// Add the result field needed
|
||||
queryOptions.documentsReturnedIn = 'nextBatch';
|
||||
|
||||
// Check if we need to promote longs
|
||||
if (typeof cursorState.promoteLongs === 'boolean') {
|
||||
queryOptions.promoteLongs = cursorState.promoteLongs;
|
||||
}
|
||||
|
||||
if (typeof cursorState.promoteValues === 'boolean') {
|
||||
queryOptions.promoteValues = cursorState.promoteValues;
|
||||
}
|
||||
|
||||
if (typeof cursorState.promoteBuffers === 'boolean') {
|
||||
queryOptions.promoteBuffers = cursorState.promoteBuffers;
|
||||
}
|
||||
|
||||
if (typeof cursorState.session === 'object') {
|
||||
queryOptions.session = cursorState.session;
|
||||
}
|
||||
|
||||
// Write out the getMore command
|
||||
connection.write(query, queryOptions, queryCallback);
|
||||
};
|
||||
|
||||
WireProtocol.prototype.command = function(bson, ns, cmd, cursorState, topology, options) {
|
||||
options = options || {};
|
||||
// Check if this is a wire protocol command or not
|
||||
const wireProtocolCommand =
|
||||
typeof options.wireProtocolCommand === 'boolean' ? options.wireProtocolCommand : true;
|
||||
|
||||
// Establish type of command
|
||||
let query;
|
||||
if (cmd.find && wireProtocolCommand) {
|
||||
// Create the find command
|
||||
query = executeFindCommand(bson, ns, cmd, cursorState, topology, options);
|
||||
|
||||
// Mark the cmd as virtual
|
||||
cmd.virtual = false;
|
||||
// Signal the documents are in the firstBatch value
|
||||
query.documentsReturnedIn = 'firstBatch';
|
||||
} else if (cursorState.cursorId != null) {
|
||||
return;
|
||||
} else if (cmd) {
|
||||
query = setupCommand(bson, ns, cmd, cursorState, topology, options);
|
||||
} else {
|
||||
return new MongoError(`command ${JSON.stringify(cmd)} does not return a cursor`);
|
||||
}
|
||||
|
||||
if (query instanceof MongoError) {
|
||||
return query;
|
||||
}
|
||||
|
||||
// optionally decorate query with transaction data
|
||||
const err = decorateWithSessionsData(query.query, options.session, options);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
return query;
|
||||
};
|
||||
|
||||
// // Command
|
||||
// {
|
||||
// find: ns
|
||||
// , query: <object>
|
||||
// , limit: <n>
|
||||
// , fields: <object>
|
||||
// , skip: <n>
|
||||
// , hint: <string>
|
||||
// , explain: <boolean>
|
||||
// , snapshot: <boolean>
|
||||
// , batchSize: <n>
|
||||
// , returnKey: <boolean>
|
||||
// , maxScan: <n>
|
||||
// , min: <n>
|
||||
// , max: <n>
|
||||
// , showDiskLoc: <boolean>
|
||||
// , comment: <string>
|
||||
// , maxTimeMS: <n>
|
||||
// , raw: <boolean>
|
||||
// , readPreference: <ReadPreference>
|
||||
// , tailable: <boolean>
|
||||
// , oplogReplay: <boolean>
|
||||
// , noCursorTimeout: <boolean>
|
||||
// , awaitdata: <boolean>
|
||||
// , exhaust: <boolean>
|
||||
// , partial: <boolean>
|
||||
// }
|
||||
|
||||
// FIND/GETMORE SPEC
|
||||
// {
|
||||
// “find”: <string>,
|
||||
// “filter”: { ... },
|
||||
// “sort”: { ... },
|
||||
// “projection”: { ... },
|
||||
// “hint”: { ... },
|
||||
// “skip”: <int>,
|
||||
// “limit”: <int>,
|
||||
// “batchSize”: <int>,
|
||||
// “singleBatch”: <bool>,
|
||||
// “comment”: <string>,
|
||||
// “maxScan”: <int>,
|
||||
// “maxTimeMS”: <int>,
|
||||
// “max”: { ... },
|
||||
// “min”: { ... },
|
||||
// “returnKey”: <bool>,
|
||||
// “showRecordId”: <bool>,
|
||||
// “snapshot”: <bool>,
|
||||
// “tailable”: <bool>,
|
||||
// “oplogReplay”: <bool>,
|
||||
// “noCursorTimeout”: <bool>,
|
||||
// “awaitData”: <bool>,
|
||||
// “partial”: <bool>,
|
||||
// “$readPreference”: { ... }
|
||||
// }
|
||||
|
||||
//
|
||||
// Execute a find command
|
||||
function executeFindCommand(bson, ns, cmd, cursorState, topology, options) {
|
||||
// Ensure we have at least some options
|
||||
options = options || {};
|
||||
// Get the readPreference
|
||||
const readPreference = getReadPreference(cmd, options);
|
||||
|
||||
// Set the optional batchSize
|
||||
cursorState.batchSize = cmd.batchSize || cursorState.batchSize;
|
||||
|
||||
// Build command namespace
|
||||
const parts = ns.split(/\./);
|
||||
// Command namespace
|
||||
const commandns = `${parts.shift()}.$cmd`;
|
||||
|
||||
// Build actual find command
|
||||
let findCmd = {
|
||||
find: parts.join('.')
|
||||
};
|
||||
|
||||
// I we provided a filter
|
||||
if (cmd.query) {
|
||||
// Check if the user is passing in the $query parameter
|
||||
if (cmd.query['$query']) {
|
||||
findCmd.filter = cmd.query['$query'];
|
||||
} else {
|
||||
findCmd.filter = cmd.query;
|
||||
}
|
||||
}
|
||||
|
||||
// Sort value
|
||||
let sortValue = cmd.sort;
|
||||
|
||||
// Handle issue of sort being an Array
|
||||
if (Array.isArray(sortValue)) {
|
||||
const sortObject = {};
|
||||
|
||||
if (sortValue.length > 0 && !Array.isArray(sortValue[0])) {
|
||||
let sortDirection = sortValue[1];
|
||||
// Translate the sort order text
|
||||
if (sortDirection === 'asc') {
|
||||
sortDirection = 1;
|
||||
} else if (sortDirection === 'desc') {
|
||||
sortDirection = -1;
|
||||
}
|
||||
|
||||
// Set the sort order
|
||||
sortObject[sortValue[0]] = sortDirection;
|
||||
} else {
|
||||
for (var i = 0; i < sortValue.length; i++) {
|
||||
let sortDirection = sortValue[i][1];
|
||||
// Translate the sort order text
|
||||
if (sortDirection === 'asc') {
|
||||
sortDirection = 1;
|
||||
} else if (sortDirection === 'desc') {
|
||||
sortDirection = -1;
|
||||
}
|
||||
|
||||
// Set the sort order
|
||||
sortObject[sortValue[i][0]] = sortDirection;
|
||||
}
|
||||
}
|
||||
|
||||
sortValue = sortObject;
|
||||
}
|
||||
|
||||
// Add sort to command
|
||||
if (cmd.sort) findCmd.sort = sortValue;
|
||||
// Add a projection to the command
|
||||
if (cmd.fields) findCmd.projection = cmd.fields;
|
||||
// Add a hint to the command
|
||||
if (cmd.hint) findCmd.hint = cmd.hint;
|
||||
// Add a skip
|
||||
if (cmd.skip) findCmd.skip = cmd.skip;
|
||||
// Add a limit
|
||||
if (cmd.limit) findCmd.limit = cmd.limit;
|
||||
|
||||
// Check if we wish to have a singleBatch
|
||||
if (cmd.limit < 0) {
|
||||
findCmd.limit = Math.abs(cmd.limit);
|
||||
findCmd.singleBatch = true;
|
||||
}
|
||||
|
||||
// Add a batchSize
|
||||
if (typeof cmd.batchSize === 'number') {
|
||||
if (cmd.batchSize < 0) {
|
||||
if (cmd.limit !== 0 && Math.abs(cmd.batchSize) < Math.abs(cmd.limit)) {
|
||||
findCmd.limit = Math.abs(cmd.batchSize);
|
||||
}
|
||||
|
||||
findCmd.singleBatch = true;
|
||||
}
|
||||
|
||||
findCmd.batchSize = Math.abs(cmd.batchSize);
|
||||
}
|
||||
|
||||
// If we have comment set
|
||||
if (cmd.comment) findCmd.comment = cmd.comment;
|
||||
|
||||
// If we have maxScan
|
||||
if (cmd.maxScan) findCmd.maxScan = cmd.maxScan;
|
||||
|
||||
// If we have maxTimeMS set
|
||||
if (cmd.maxTimeMS) findCmd.maxTimeMS = cmd.maxTimeMS;
|
||||
|
||||
// If we have min
|
||||
if (cmd.min) findCmd.min = cmd.min;
|
||||
|
||||
// If we have max
|
||||
if (cmd.max) findCmd.max = cmd.max;
|
||||
|
||||
// If we have returnKey set
|
||||
findCmd.returnKey = cmd.returnKey ? cmd.returnKey : false;
|
||||
|
||||
// If we have showDiskLoc set
|
||||
findCmd.showRecordId = cmd.showDiskLoc ? cmd.showDiskLoc : false;
|
||||
|
||||
// If we have snapshot set
|
||||
if (cmd.snapshot) findCmd.snapshot = cmd.snapshot;
|
||||
|
||||
// If we have tailable set
|
||||
if (cmd.tailable) findCmd.tailable = cmd.tailable;
|
||||
|
||||
// If we have oplogReplay set
|
||||
if (cmd.oplogReplay) findCmd.oplogReplay = cmd.oplogReplay;
|
||||
|
||||
// If we have noCursorTimeout set
|
||||
if (cmd.noCursorTimeout) findCmd.noCursorTimeout = cmd.noCursorTimeout;
|
||||
|
||||
// If we have awaitData set
|
||||
if (cmd.awaitData) findCmd.awaitData = cmd.awaitData;
|
||||
if (cmd.awaitdata) findCmd.awaitData = cmd.awaitdata;
|
||||
|
||||
// If we have partial set
|
||||
if (cmd.partial) findCmd.partial = cmd.partial;
|
||||
|
||||
// If we have collation passed in
|
||||
if (cmd.collation) findCmd.collation = cmd.collation;
|
||||
|
||||
// If we have explain, we need to rewrite the find command
|
||||
// to wrap it in the explain command
|
||||
if (cmd.explain) {
|
||||
findCmd = {
|
||||
explain: findCmd
|
||||
};
|
||||
}
|
||||
|
||||
// Did we provide a readConcern
|
||||
if (cmd.readConcern) findCmd.readConcern = cmd.readConcern;
|
||||
|
||||
// Set up the serialize and ignoreUndefined fields
|
||||
const serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
const ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
|
||||
|
||||
// We have a Mongos topology, check if we need to add a readPreference
|
||||
if (topology.type === 'mongos' && readPreference && readPreference.preference !== 'primary') {
|
||||
findCmd = {
|
||||
$query: findCmd,
|
||||
$readPreference: readPreference.toJSON()
|
||||
};
|
||||
}
|
||||
|
||||
// optionally decorate query with transaction data
|
||||
const err = decorateWithSessionsData(findCmd, options.session, options);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
// Build Query object
|
||||
const query = new Query(bson, commandns, findCmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: 1,
|
||||
checkKeys: false,
|
||||
returnFieldSelector: null,
|
||||
serializeFunctions: serializeFunctions,
|
||||
ignoreUndefined: ignoreUndefined
|
||||
});
|
||||
|
||||
// Set query flags
|
||||
query.slaveOk = readPreference.slaveOk();
|
||||
|
||||
// Return the query
|
||||
return query;
|
||||
}
|
||||
|
||||
//
|
||||
// Set up a command cursor
|
||||
function setupCommand(bson, ns, cmd, cursorState, topology, options) {
|
||||
// Set empty options object
|
||||
options = options || {};
|
||||
// Get the readPreference
|
||||
const readPreference = getReadPreference(cmd, options);
|
||||
|
||||
// Final query
|
||||
let finalCmd = {};
|
||||
for (let name in cmd) {
|
||||
finalCmd[name] = cmd[name];
|
||||
}
|
||||
|
||||
// Build command namespace
|
||||
const parts = ns.split(/\./);
|
||||
|
||||
// Serialize functions
|
||||
const serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
|
||||
// Set up the serialize and ignoreUndefined fields
|
||||
const ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : false;
|
||||
|
||||
// We have a Mongos topology, check if we need to add a readPreference
|
||||
if (topology.type === 'mongos' && readPreference && readPreference.preference !== 'primary') {
|
||||
finalCmd = {
|
||||
$query: finalCmd,
|
||||
$readPreference: readPreference.toJSON()
|
||||
};
|
||||
}
|
||||
|
||||
// optionally decorate query with transaction data
|
||||
const err = decorateWithSessionsData(finalCmd, options.session, options);
|
||||
if (err) {
|
||||
return err;
|
||||
}
|
||||
|
||||
// Build Query object
|
||||
const query = new Query(bson, `${parts.shift()}.$cmd`, finalCmd, {
|
||||
numberToSkip: 0,
|
||||
numberToReturn: -1,
|
||||
checkKeys: false,
|
||||
serializeFunctions: serializeFunctions,
|
||||
ignoreUndefined: ignoreUndefined
|
||||
});
|
||||
|
||||
// Set query flags
|
||||
query.slaveOk = readPreference.slaveOk();
|
||||
|
||||
// Return the query
|
||||
return query;
|
||||
}
|
||||
|
||||
module.exports = WireProtocol;
|
||||
+73
@@ -0,0 +1,73 @@
|
||||
'use strict';
|
||||
|
||||
var Snappy = require('../connection/utils').retrieveSnappy(),
|
||||
zlib = require('zlib');
|
||||
|
||||
var compressorIDs = {
|
||||
snappy: 1,
|
||||
zlib: 2
|
||||
};
|
||||
|
||||
var uncompressibleCommands = [
|
||||
'ismaster',
|
||||
'saslStart',
|
||||
'saslContinue',
|
||||
'getnonce',
|
||||
'authenticate',
|
||||
'createUser',
|
||||
'updateUser',
|
||||
'copydbSaslStart',
|
||||
'copydbgetnonce',
|
||||
'copydb'
|
||||
];
|
||||
|
||||
// Facilitate compressing a message using an agreed compressor
|
||||
var compress = function(self, dataToBeCompressed, callback) {
|
||||
switch (self.options.agreedCompressor) {
|
||||
case 'snappy':
|
||||
Snappy.compress(dataToBeCompressed, callback);
|
||||
break;
|
||||
case 'zlib':
|
||||
// Determine zlibCompressionLevel
|
||||
var zlibOptions = {};
|
||||
if (self.options.zlibCompressionLevel) {
|
||||
zlibOptions.level = self.options.zlibCompressionLevel;
|
||||
}
|
||||
zlib.deflate(dataToBeCompressed, zlibOptions, callback);
|
||||
break;
|
||||
default:
|
||||
throw new Error(
|
||||
'Attempt to compress message using unknown compressor "' +
|
||||
self.options.agreedCompressor +
|
||||
'".'
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
// Decompress a message using the given compressor
|
||||
var decompress = function(compressorID, compressedData, callback) {
|
||||
if (compressorID < 0 || compressorID > compressorIDs.length) {
|
||||
throw new Error(
|
||||
'Server sent message compressed using an unsupported compressor. (Received compressor ID ' +
|
||||
compressorID +
|
||||
')'
|
||||
);
|
||||
}
|
||||
switch (compressorID) {
|
||||
case compressorIDs.snappy:
|
||||
Snappy.uncompress(compressedData, callback);
|
||||
break;
|
||||
case compressorIDs.zlib:
|
||||
zlib.inflate(compressedData, callback);
|
||||
break;
|
||||
default:
|
||||
callback(null, compressedData);
|
||||
}
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
compressorIDs: compressorIDs,
|
||||
uncompressibleCommands: uncompressibleCommands,
|
||||
compress: compress,
|
||||
decompress: decompress
|
||||
};
|
||||
+55
@@ -0,0 +1,55 @@
|
||||
'use strict';
|
||||
|
||||
var ReadPreference = require('../topologies/read_preference'),
|
||||
MongoError = require('../error').MongoError;
|
||||
|
||||
var MESSAGE_HEADER_SIZE = 16;
|
||||
|
||||
// OPCODE Numbers
|
||||
// Defined at https://docs.mongodb.com/manual/reference/mongodb-wire-protocol/#request-opcodes
|
||||
var opcodes = {
|
||||
OP_REPLY: 1,
|
||||
OP_UPDATE: 2001,
|
||||
OP_INSERT: 2002,
|
||||
OP_QUERY: 2004,
|
||||
OP_GETMORE: 2005,
|
||||
OP_DELETE: 2006,
|
||||
OP_KILL_CURSORS: 2007,
|
||||
OP_COMPRESSED: 2012
|
||||
};
|
||||
|
||||
var getReadPreference = function(cmd, options) {
|
||||
// Default to command version of the readPreference
|
||||
var readPreference = cmd.readPreference || new ReadPreference('primary');
|
||||
// If we have an option readPreference override the command one
|
||||
if (options.readPreference) {
|
||||
readPreference = options.readPreference;
|
||||
}
|
||||
|
||||
if (typeof readPreference === 'string') {
|
||||
readPreference = new ReadPreference(readPreference);
|
||||
}
|
||||
|
||||
if (!(readPreference instanceof ReadPreference)) {
|
||||
throw new MongoError('read preference must be a ReadPreference instance');
|
||||
}
|
||||
|
||||
return readPreference;
|
||||
};
|
||||
|
||||
// Parses the header of a wire protocol message
|
||||
var parseHeader = function(message) {
|
||||
return {
|
||||
length: message.readInt32LE(0),
|
||||
requestId: message.readInt32LE(4),
|
||||
responseTo: message.readInt32LE(8),
|
||||
opCode: message.readInt32LE(12)
|
||||
};
|
||||
};
|
||||
|
||||
module.exports = {
|
||||
getReadPreference: getReadPreference,
|
||||
MESSAGE_HEADER_SIZE: MESSAGE_HEADER_SIZE,
|
||||
opcodes: opcodes,
|
||||
parseHeader: parseHeader
|
||||
};
|
||||
+253
@@ -0,0 +1,253 @@
|
||||
<a name="1.1.0"></a>
|
||||
# [1.1.0](https://github.com/mongodb/js-bson/compare/v1.0.9...v1.1.0) (2018-08-13)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **serializer:** do not use checkKeys for $clusterTime ([573e141](https://github.com/mongodb/js-bson/commit/573e141))
|
||||
|
||||
|
||||
|
||||
<a name="1.0.9"></a>
|
||||
## [1.0.9](https://github.com/mongodb/js-bson/compare/v1.0.8...v1.0.9) (2018-06-07)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **serializer:** remove use of `const` ([5feb12f](https://github.com/mongodb/js-bson/commit/5feb12f))
|
||||
|
||||
|
||||
|
||||
<a name="1.0.7"></a>
|
||||
## [1.0.7](https://github.com/mongodb/js-bson/compare/v1.0.6...v1.0.7) (2018-06-06)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **binary:** add type checking for buffer ([26b05b5](https://github.com/mongodb/js-bson/commit/26b05b5))
|
||||
* **bson:** fix custom inspect property ([080323b](https://github.com/mongodb/js-bson/commit/080323b))
|
||||
* **readme:** clarify documentation about deserialize methods ([20f764c](https://github.com/mongodb/js-bson/commit/20f764c))
|
||||
* **serialization:** normalize function stringification ([1320c10](https://github.com/mongodb/js-bson/commit/1320c10))
|
||||
|
||||
|
||||
|
||||
<a name="1.0.6"></a>
|
||||
## [1.0.6](https://github.com/mongodb/js-bson/compare/v1.0.5...v1.0.6) (2018-03-12)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* **serialization:** support arbitrary sizes for the internal serialization buffer ([abe97bc](https://github.com/mongodb/js-bson/commit/abe97bc))
|
||||
|
||||
|
||||
|
||||
<a name="1.0.5"></a>
|
||||
## 1.0.5 (2018-02-26)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* **decimal128:** add basic guard against REDOS attacks ([bd61c45](https://github.com/mongodb/js-bson/commit/bd61c45))
|
||||
* **objectid:** if pid is 1, use random value ([e188ae6](https://github.com/mongodb/js-bson/commit/e188ae6))
|
||||
|
||||
|
||||
|
||||
1.0.4 2016-01-11
|
||||
----------------
|
||||
- #204 remove Buffer.from as it's partially broken in early 4.x.x. series of node releases.
|
||||
|
||||
1.0.3 2016-01-03
|
||||
----------------
|
||||
- Fixed toString for ObjectId so it will work with inspect.
|
||||
|
||||
1.0.2 2016-01-02
|
||||
----------------
|
||||
- Minor optimizations for ObjectID to use Buffer.from where available.
|
||||
|
||||
1.0.1 2016-12-06
|
||||
----------------
|
||||
- Reverse behavior for undefined to be serialized as NULL. MongoDB 3.4 does not allow for undefined comparisons.
|
||||
|
||||
1.0.0 2016-12-06
|
||||
----------------
|
||||
- Introduced new BSON API and documentation.
|
||||
|
||||
0.5.7 2016-11-18
|
||||
-----------------
|
||||
- NODE-848 BSON Regex flags must be alphabetically ordered.
|
||||
|
||||
0.5.6 2016-10-19
|
||||
-----------------
|
||||
- NODE-833, Detects cyclic dependencies in documents and throws error if one is found.
|
||||
- Fix(deserializer): corrected the check for (size + index) comparison… (Issue #195, https://github.com/JoelParke).
|
||||
|
||||
0.5.5 2016-09-15
|
||||
-----------------
|
||||
- Added DBPointer up conversion to DBRef
|
||||
|
||||
0.5.4 2016-08-23
|
||||
-----------------
|
||||
- Added promoteValues flag (default to true) allowing user to specify if deserialization should be into wrapper classes only.
|
||||
|
||||
0.5.3 2016-07-11
|
||||
-----------------
|
||||
- Throw error if ObjectId is not a string or a buffer.
|
||||
|
||||
0.5.2 2016-07-11
|
||||
-----------------
|
||||
- All values encoded big-endian style for ObjectId.
|
||||
|
||||
0.5.1 2016-07-11
|
||||
-----------------
|
||||
- Fixed encoding/decoding issue in ObjectId timestamp generation.
|
||||
- Removed BinaryParser dependency from the serializer/deserializer.
|
||||
|
||||
0.5.0 2016-07-05
|
||||
-----------------
|
||||
- Added Decimal128 type and extended test suite to include entire bson corpus.
|
||||
|
||||
0.4.23 2016-04-08
|
||||
-----------------
|
||||
- Allow for proper detection of ObjectId or objects that look like ObjectId, improving compatibility across third party libraries.
|
||||
- Remove one package from dependency due to having been pulled from NPM.
|
||||
|
||||
0.4.22 2016-03-04
|
||||
-----------------
|
||||
- Fix "TypeError: data.copy is not a function" in Electron (Issue #170, https://github.com/kangas).
|
||||
- Fixed issue with undefined type on deserializing.
|
||||
|
||||
0.4.21 2016-01-12
|
||||
-----------------
|
||||
- Minor optimizations to avoid non needed object creation.
|
||||
|
||||
0.4.20 2015-10-15
|
||||
-----------------
|
||||
- Added bower file to repository.
|
||||
- Fixed browser pid sometimes set greater than 0xFFFF on browsers (Issue #155, https://github.com/rahatarmanahmed)
|
||||
|
||||
0.4.19 2015-10-15
|
||||
-----------------
|
||||
- Remove all support for bson-ext.
|
||||
|
||||
0.4.18 2015-10-15
|
||||
-----------------
|
||||
- ObjectID equality check should return boolean instead of throwing exception for invalid oid string #139
|
||||
- add option for deserializing binary into Buffer object #116
|
||||
|
||||
0.4.17 2015-10-15
|
||||
-----------------
|
||||
- Validate regexp string for null bytes and throw if there is one.
|
||||
|
||||
0.4.16 2015-10-07
|
||||
-----------------
|
||||
- Fixed issue with return statement in Map.js.
|
||||
|
||||
0.4.15 2015-10-06
|
||||
-----------------
|
||||
- Exposed Map correctly via index.js file.
|
||||
|
||||
0.4.14 2015-10-06
|
||||
-----------------
|
||||
- Exposed Map correctly via bson.js file.
|
||||
|
||||
0.4.13 2015-10-06
|
||||
-----------------
|
||||
- Added ES6 Map type serialization as well as a polyfill for ES5.
|
||||
|
||||
0.4.12 2015-09-18
|
||||
-----------------
|
||||
- Made ignore undefined an optional parameter.
|
||||
|
||||
0.4.11 2015-08-06
|
||||
-----------------
|
||||
- Minor fix for invalid key checking.
|
||||
|
||||
0.4.10 2015-08-06
|
||||
-----------------
|
||||
- NODE-38 Added new BSONRegExp type to allow direct serialization to MongoDB type.
|
||||
- Some performance improvements by in lining code.
|
||||
|
||||
0.4.9 2015-08-06
|
||||
----------------
|
||||
- Undefined fields are omitted from serialization in objects.
|
||||
|
||||
0.4.8 2015-07-14
|
||||
----------------
|
||||
- Fixed size validation to ensure we can deserialize from dumped files.
|
||||
|
||||
0.4.7 2015-06-26
|
||||
----------------
|
||||
- Added ability to instruct deserializer to return raw BSON buffers for named array fields.
|
||||
- Minor deserialization optimization by moving inlined function out.
|
||||
|
||||
0.4.6 2015-06-17
|
||||
----------------
|
||||
- Fixed serializeWithBufferAndIndex bug.
|
||||
|
||||
0.4.5 2015-06-17
|
||||
----------------
|
||||
- Removed any references to the shared buffer to avoid non GC collectible bson instances.
|
||||
|
||||
0.4.4 2015-06-17
|
||||
----------------
|
||||
- Fixed rethrowing of error when not RangeError.
|
||||
|
||||
0.4.3 2015-06-17
|
||||
----------------
|
||||
- Start buffer at 64K and double as needed, meaning we keep a low memory profile until needed.
|
||||
|
||||
0.4.2 2015-06-16
|
||||
----------------
|
||||
- More fixes for corrupt Bson
|
||||
|
||||
0.4.1 2015-06-16
|
||||
----------------
|
||||
- More fixes for corrupt Bson
|
||||
|
||||
0.4.0 2015-06-16
|
||||
----------------
|
||||
- New JS serializer serializing into a single buffer then copying out the new buffer. Performance is similar to current C++ parser.
|
||||
- Removed bson-ext extension dependency for now.
|
||||
|
||||
0.3.2 2015-03-27
|
||||
----------------
|
||||
- Removed node-gyp from install script in package.json.
|
||||
|
||||
0.3.1 2015-03-27
|
||||
----------------
|
||||
- Return pure js version on native() call if failed to initialize.
|
||||
|
||||
0.3.0 2015-03-26
|
||||
----------------
|
||||
- Pulled out all C++ code into bson-ext and made it an optional dependency.
|
||||
|
||||
0.2.21 2015-03-21
|
||||
-----------------
|
||||
- Updated Nan to 1.7.0 to support io.js and node 0.12.0
|
||||
|
||||
0.2.19 2015-02-16
|
||||
-----------------
|
||||
- Updated Nan to 1.6.2 to support io.js and node 0.12.0
|
||||
|
||||
0.2.18 2015-01-20
|
||||
-----------------
|
||||
- Updated Nan to 1.5.1 to support io.js
|
||||
|
||||
0.2.16 2014-12-17
|
||||
-----------------
|
||||
- Made pid cycle on 0xffff to avoid weird overflows on creation of ObjectID's
|
||||
|
||||
0.2.12 2014-08-24
|
||||
-----------------
|
||||
- Fixes for fortify review of c++ extension
|
||||
- toBSON correctly allows returns of non objects
|
||||
|
||||
0.2.3 2013-10-01
|
||||
----------------
|
||||
- Drying of ObjectId code for generation of id (Issue #54, https://github.com/moredip)
|
||||
- Fixed issue where corrupt CString's could cause endless loop
|
||||
- Support for Node 0.11.X > (Issue #49, https://github.com/kkoopa)
|
||||
|
||||
0.1.4 2012-09-25
|
||||
----------------
|
||||
- Added precompiled c++ native extensions for win32 ia32 and x64
|
||||
+201
@@ -0,0 +1,201 @@
|
||||
Apache License
|
||||
Version 2.0, January 2004
|
||||
http://www.apache.org/licenses/
|
||||
|
||||
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
|
||||
1. Definitions.
|
||||
|
||||
"License" shall mean the terms and conditions for use, reproduction,
|
||||
and distribution as defined by Sections 1 through 9 of this document.
|
||||
|
||||
"Licensor" shall mean the copyright owner or entity authorized by
|
||||
the copyright owner that is granting the License.
|
||||
|
||||
"Legal Entity" shall mean the union of the acting entity and all
|
||||
other entities that control, are controlled by, or are under common
|
||||
control with that entity. For the purposes of this definition,
|
||||
"control" means (i) the power, direct or indirect, to cause the
|
||||
direction or management of such entity, whether by contract or
|
||||
otherwise, or (ii) ownership of fifty percent (50%) or more of the
|
||||
outstanding shares, or (iii) beneficial ownership of such entity.
|
||||
|
||||
"You" (or "Your") shall mean an individual or Legal Entity
|
||||
exercising permissions granted by this License.
|
||||
|
||||
"Source" form shall mean the preferred form for making modifications,
|
||||
including but not limited to software source code, documentation
|
||||
source, and configuration files.
|
||||
|
||||
"Object" form shall mean any form resulting from mechanical
|
||||
transformation or translation of a Source form, including but
|
||||
not limited to compiled object code, generated documentation,
|
||||
and conversions to other media types.
|
||||
|
||||
"Work" shall mean the work of authorship, whether in Source or
|
||||
Object form, made available under the License, as indicated by a
|
||||
copyright notice that is included in or attached to the work
|
||||
(an example is provided in the Appendix below).
|
||||
|
||||
"Derivative Works" shall mean any work, whether in Source or Object
|
||||
form, that is based on (or derived from) the Work and for which the
|
||||
editorial revisions, annotations, elaborations, or other modifications
|
||||
represent, as a whole, an original work of authorship. For the purposes
|
||||
of this License, Derivative Works shall not include works that remain
|
||||
separable from, or merely link (or bind by name) to the interfaces of,
|
||||
the Work and Derivative Works thereof.
|
||||
|
||||
"Contribution" shall mean any work of authorship, including
|
||||
the original version of the Work and any modifications or additions
|
||||
to that Work or Derivative Works thereof, that is intentionally
|
||||
submitted to Licensor for inclusion in the Work by the copyright owner
|
||||
or by an individual or Legal Entity authorized to submit on behalf of
|
||||
the copyright owner. For the purposes of this definition, "submitted"
|
||||
means any form of electronic, verbal, or written communication sent
|
||||
to the Licensor or its representatives, including but not limited to
|
||||
communication on electronic mailing lists, source code control systems,
|
||||
and issue tracking systems that are managed by, or on behalf of, the
|
||||
Licensor for the purpose of discussing and improving the Work, but
|
||||
excluding communication that is conspicuously marked or otherwise
|
||||
designated in writing by the copyright owner as "Not a Contribution."
|
||||
|
||||
"Contributor" shall mean Licensor and any individual or Legal Entity
|
||||
on behalf of whom a Contribution has been received by Licensor and
|
||||
subsequently incorporated within the Work.
|
||||
|
||||
2. Grant of Copyright License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
copyright license to reproduce, prepare Derivative Works of,
|
||||
publicly display, publicly perform, sublicense, and distribute the
|
||||
Work and such Derivative Works in Source or Object form.
|
||||
|
||||
3. Grant of Patent License. Subject to the terms and conditions of
|
||||
this License, each Contributor hereby grants to You a perpetual,
|
||||
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
|
||||
(except as stated in this section) patent license to make, have made,
|
||||
use, offer to sell, sell, import, and otherwise transfer the Work,
|
||||
where such license applies only to those patent claims licensable
|
||||
by such Contributor that are necessarily infringed by their
|
||||
Contribution(s) alone or by combination of their Contribution(s)
|
||||
with the Work to which such Contribution(s) was submitted. If You
|
||||
institute patent litigation against any entity (including a
|
||||
cross-claim or counterclaim in a lawsuit) alleging that the Work
|
||||
or a Contribution incorporated within the Work constitutes direct
|
||||
or contributory patent infringement, then any patent licenses
|
||||
granted to You under this License for that Work shall terminate
|
||||
as of the date such litigation is filed.
|
||||
|
||||
4. Redistribution. You may reproduce and distribute copies of the
|
||||
Work or Derivative Works thereof in any medium, with or without
|
||||
modifications, and in Source or Object form, provided that You
|
||||
meet the following conditions:
|
||||
|
||||
(a) You must give any other recipients of the Work or
|
||||
Derivative Works a copy of this License; and
|
||||
|
||||
(b) You must cause any modified files to carry prominent notices
|
||||
stating that You changed the files; and
|
||||
|
||||
(c) You must retain, in the Source form of any Derivative Works
|
||||
that You distribute, all copyright, patent, trademark, and
|
||||
attribution notices from the Source form of the Work,
|
||||
excluding those notices that do not pertain to any part of
|
||||
the Derivative Works; and
|
||||
|
||||
(d) If the Work includes a "NOTICE" text file as part of its
|
||||
distribution, then any Derivative Works that You distribute must
|
||||
include a readable copy of the attribution notices contained
|
||||
within such NOTICE file, excluding those notices that do not
|
||||
pertain to any part of the Derivative Works, in at least one
|
||||
of the following places: within a NOTICE text file distributed
|
||||
as part of the Derivative Works; within the Source form or
|
||||
documentation, if provided along with the Derivative Works; or,
|
||||
within a display generated by the Derivative Works, if and
|
||||
wherever such third-party notices normally appear. The contents
|
||||
of the NOTICE file are for informational purposes only and
|
||||
do not modify the License. You may add Your own attribution
|
||||
notices within Derivative Works that You distribute, alongside
|
||||
or as an addendum to the NOTICE text from the Work, provided
|
||||
that such additional attribution notices cannot be construed
|
||||
as modifying the License.
|
||||
|
||||
You may add Your own copyright statement to Your modifications and
|
||||
may provide additional or different license terms and conditions
|
||||
for use, reproduction, or distribution of Your modifications, or
|
||||
for any such Derivative Works as a whole, provided Your use,
|
||||
reproduction, and distribution of the Work otherwise complies with
|
||||
the conditions stated in this License.
|
||||
|
||||
5. Submission of Contributions. Unless You explicitly state otherwise,
|
||||
any Contribution intentionally submitted for inclusion in the Work
|
||||
by You to the Licensor shall be under the terms and conditions of
|
||||
this License, without any additional terms or conditions.
|
||||
Notwithstanding the above, nothing herein shall supersede or modify
|
||||
the terms of any separate license agreement you may have executed
|
||||
with Licensor regarding such Contributions.
|
||||
|
||||
6. Trademarks. This License does not grant permission to use the trade
|
||||
names, trademarks, service marks, or product names of the Licensor,
|
||||
except as required for reasonable and customary use in describing the
|
||||
origin of the Work and reproducing the content of the NOTICE file.
|
||||
|
||||
7. Disclaimer of Warranty. Unless required by applicable law or
|
||||
agreed to in writing, Licensor provides the Work (and each
|
||||
Contributor provides its Contributions) on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
|
||||
implied, including, without limitation, any warranties or conditions
|
||||
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
|
||||
PARTICULAR PURPOSE. You are solely responsible for determining the
|
||||
appropriateness of using or redistributing the Work and assume any
|
||||
risks associated with Your exercise of permissions under this License.
|
||||
|
||||
8. Limitation of Liability. In no event and under no legal theory,
|
||||
whether in tort (including negligence), contract, or otherwise,
|
||||
unless required by applicable law (such as deliberate and grossly
|
||||
negligent acts) or agreed to in writing, shall any Contributor be
|
||||
liable to You for damages, including any direct, indirect, special,
|
||||
incidental, or consequential damages of any character arising as a
|
||||
result of this License or out of the use or inability to use the
|
||||
Work (including but not limited to damages for loss of goodwill,
|
||||
work stoppage, computer failure or malfunction, or any and all
|
||||
other commercial damages or losses), even if such Contributor
|
||||
has been advised of the possibility of such damages.
|
||||
|
||||
9. Accepting Warranty or Additional Liability. While redistributing
|
||||
the Work or Derivative Works thereof, You may choose to offer,
|
||||
and charge a fee for, acceptance of support, warranty, indemnity,
|
||||
or other liability obligations and/or rights consistent with this
|
||||
License. However, in accepting such obligations, You may act only
|
||||
on Your own behalf and on Your sole responsibility, not on behalf
|
||||
of any other Contributor, and only if You agree to indemnify,
|
||||
defend, and hold each Contributor harmless for any liability
|
||||
incurred by, or claims asserted against, such Contributor by reason
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
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.
|
||||
+170
@@ -0,0 +1,170 @@
|
||||
# BSON parser
|
||||
|
||||
BSON is short for Binary JSON and is the binary-encoded serialization of JSON-like documents. You can learn more about it in [the specification](http://bsonspec.org).
|
||||
|
||||
This browser version of the BSON parser is compiled using [webpack](https://webpack.js.org/) and the current version is pre-compiled in the `browser_build` directory.
|
||||
|
||||
This is the default BSON parser, however, there is a C++ Node.js addon version as well that does not support the browser. It can be found at [mongod-js/bson-ext](https://github.com/mongodb-js/bson-ext).
|
||||
|
||||
## Usage
|
||||
|
||||
To build a new version perform the following operations:
|
||||
|
||||
```
|
||||
npm install
|
||||
npm run build
|
||||
```
|
||||
|
||||
A simple example of how to use BSON in the browser:
|
||||
|
||||
```html
|
||||
<script src="./browser_build/bson.js"></script>
|
||||
|
||||
<script>
|
||||
function start() {
|
||||
// Get the Long type
|
||||
var Long = BSON.Long;
|
||||
// Create a bson parser instance
|
||||
var bson = new BSON();
|
||||
|
||||
// Serialize document
|
||||
var doc = { long: Long.fromNumber(100) }
|
||||
|
||||
// Serialize a document
|
||||
var data = bson.serialize(doc)
|
||||
// De serialize it again
|
||||
var doc_2 = bson.deserialize(data)
|
||||
}
|
||||
</script>
|
||||
```
|
||||
|
||||
A simple example of how to use BSON in `Node.js`:
|
||||
|
||||
```js
|
||||
// Get BSON parser class
|
||||
var BSON = require('bson')
|
||||
// Get the Long type
|
||||
var Long = BSON.Long;
|
||||
// Create a bson parser instance
|
||||
var bson = new BSON();
|
||||
|
||||
// Serialize document
|
||||
var doc = { long: Long.fromNumber(100) }
|
||||
|
||||
// Serialize a document
|
||||
var data = bson.serialize(doc)
|
||||
console.log('data:', data)
|
||||
|
||||
// Deserialize the resulting Buffer
|
||||
var doc_2 = bson.deserialize(data)
|
||||
console.log('doc_2:', doc_2)
|
||||
```
|
||||
|
||||
## Installation
|
||||
|
||||
`npm install bson`
|
||||
|
||||
## API
|
||||
|
||||
### BSON types
|
||||
|
||||
For all BSON types documentation, please refer to the following sources:
|
||||
* [MongoDB BSON Type Reference](https://docs.mongodb.com/manual/reference/bson-types/)
|
||||
* [BSON Spec](https://bsonspec.org/)
|
||||
|
||||
### BSON serialization and deserialiation
|
||||
|
||||
**`new BSON()`** - Creates a new BSON serializer/deserializer you can use to serialize and deserialize BSON.
|
||||
|
||||
#### BSON.serialize
|
||||
|
||||
The BSON `serialize` method takes a JavaScript object and an optional options object and returns a Node.js Buffer.
|
||||
|
||||
* `BSON.serialize(object, options)`
|
||||
* @param {Object} object the JavaScript object to serialize.
|
||||
* @param {Boolean} [options.checkKeys=false] the serializer will check if keys are valid.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the JavaScript functions.
|
||||
* @param {Boolean} [options.ignoreUndefined=true]
|
||||
* @return {Buffer} returns a Buffer instance.
|
||||
|
||||
#### BSON.serializeWithBufferAndIndex
|
||||
|
||||
The BSON `serializeWithBufferAndIndex` method takes an object, a target buffer instance and an optional options object and returns the end serialization index in the final buffer.
|
||||
|
||||
* `BSON.serializeWithBufferAndIndex(object, buffer, options)`
|
||||
* @param {Object} object the JavaScript object to serialize.
|
||||
* @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.
|
||||
* @param {Boolean} [options.checkKeys=false] the serializer will check if keys are valid.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the JavaScript functions.
|
||||
* @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields.
|
||||
* @param {Number} [options.index=0] the index in the buffer where we wish to start serializing into.
|
||||
* @return {Number} returns the index pointing to the last written byte in the buffer.
|
||||
|
||||
#### BSON.calculateObjectSize
|
||||
|
||||
The BSON `calculateObjectSize` method takes a JavaScript object and an optional options object and returns the size of the BSON object.
|
||||
|
||||
* `BSON.calculateObjectSize(object, options)`
|
||||
* @param {Object} object the JavaScript object to serialize.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the JavaScript functions.
|
||||
* @param {Boolean} [options.ignoreUndefined=true]
|
||||
* @return {Buffer} returns a Buffer instance.
|
||||
|
||||
#### BSON.deserialize
|
||||
|
||||
The BSON `deserialize` method takes a Node.js Buffer and an optional options object and returns a deserialized JavaScript object.
|
||||
|
||||
* `BSON.deserialize(buffer, options)`
|
||||
* @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.
|
||||
* @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.
|
||||
* @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.
|
||||
* @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
||||
* @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a Node.js Buffer instance.
|
||||
* @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.
|
||||
* @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.
|
||||
* @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.
|
||||
* @return {Object} returns the deserialized Javascript Object.
|
||||
|
||||
#### BSON.deserializeStream
|
||||
|
||||
The BSON `deserializeStream` method takes a Node.js Buffer, `startIndex` and allow more control over deserialization of a Buffer containing concatenated BSON documents.
|
||||
|
||||
* `BSON.deserializeStream(buffer, startIndex, numberOfDocuments, documents, docStartIndex, options)`
|
||||
* @param {Buffer} buffer the buffer containing the serialized set of BSON documents.
|
||||
* @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.
|
||||
* @param {Number} numberOfDocuments number of documents to deserialize.
|
||||
* @param {Array} documents an array where to store the deserialized documents.
|
||||
* @param {Number} docStartIndex the index in the documents array from where to start inserting documents.
|
||||
* @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.
|
||||
* @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.
|
||||
* @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.
|
||||
* @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
||||
* @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a Node.js Buffer instance.
|
||||
* @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.
|
||||
* @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.
|
||||
* @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.
|
||||
* @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.
|
||||
|
||||
## FAQ
|
||||
|
||||
#### Why does `undefined` get converted to `null`?
|
||||
|
||||
The `undefined` BSON type has been [deprecated for many years](http://bsonspec.org/spec.html), so this library has dropped support for it. Use the `ignoreUndefined` option (for example, from the [driver](http://mongodb.github.io/node-mongodb-native/2.2/api/MongoClient.html#connect) ) to instead remove `undefined` keys.
|
||||
|
||||
#### How do I add custom serialization logic?
|
||||
|
||||
This library looks for `toBSON()` functions on every path, and calls the `toBSON()` function to get the value to serialize.
|
||||
|
||||
```javascript
|
||||
var bson = new BSON();
|
||||
|
||||
class CustomSerialize {
|
||||
toBSON() {
|
||||
return 42;
|
||||
}
|
||||
}
|
||||
|
||||
const obj = { answer: new CustomSerialize() };
|
||||
// "{ answer: 42 }"
|
||||
console.log(bson.deserialize(bson.serialize(obj)));
|
||||
```
|
||||
+25
@@ -0,0 +1,25 @@
|
||||
{
|
||||
"name": "bson",
|
||||
"description": "A bson parser for node.js and the browser",
|
||||
"keywords": [
|
||||
"mongodb",
|
||||
"bson",
|
||||
"parser"
|
||||
],
|
||||
"author": "Christian Amor Kvalheim <christkv@gmail.com>",
|
||||
"main": "./browser_build/bson.js",
|
||||
"license": "Apache-2.0",
|
||||
"moduleType": [
|
||||
"globals",
|
||||
"node"
|
||||
],
|
||||
"ignore": [
|
||||
"**/.*",
|
||||
"alternate_parsers",
|
||||
"benchmarks",
|
||||
"bower_components",
|
||||
"node_modules",
|
||||
"test",
|
||||
"tools"
|
||||
]
|
||||
}
|
||||
+17748
File diff suppressed because it is too large.
Load diff
+8
@@ -0,0 +1,8 @@
|
||||
{ "name" : "bson"
|
||||
, "description" : "A bson parser for node.js and the browser"
|
||||
, "main": "../"
|
||||
, "directories" : { "lib" : "../lib/bson" }
|
||||
, "engines" : { "node" : ">=0.6.0" }
|
||||
, "licenses" : [ { "type" : "Apache License, Version 2.0"
|
||||
, "url" : "http://www.apache.org/licenses/LICENSE-2.0" } ]
|
||||
}
|
||||
+46
@@ -0,0 +1,46 @@
|
||||
var BSON = require('./lib/bson/bson'),
|
||||
Binary = require('./lib/bson/binary'),
|
||||
Code = require('./lib/bson/code'),
|
||||
DBRef = require('./lib/bson/db_ref'),
|
||||
Decimal128 = require('./lib/bson/decimal128'),
|
||||
Double = require('./lib/bson/double'),
|
||||
Int32 = require('./lib/bson/int_32'),
|
||||
Long = require('./lib/bson/long'),
|
||||
Map = require('./lib/bson/map'),
|
||||
MaxKey = require('./lib/bson/max_key'),
|
||||
MinKey = require('./lib/bson/min_key'),
|
||||
ObjectId = require('./lib/bson/objectid'),
|
||||
BSONRegExp = require('./lib/bson/regexp'),
|
||||
Symbol = require('./lib/bson/symbol'),
|
||||
Timestamp = require('./lib/bson/timestamp');
|
||||
|
||||
// BSON MAX VALUES
|
||||
BSON.BSON_INT32_MAX = 0x7fffffff;
|
||||
BSON.BSON_INT32_MIN = -0x80000000;
|
||||
|
||||
BSON.BSON_INT64_MAX = Math.pow(2, 63) - 1;
|
||||
BSON.BSON_INT64_MIN = -Math.pow(2, 63);
|
||||
|
||||
// JS MAX PRECISE VALUES
|
||||
BSON.JS_INT_MAX = 0x20000000000000; // Any integer up to 2^53 can be precisely represented by a double.
|
||||
BSON.JS_INT_MIN = -0x20000000000000; // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
// Add BSON types to function creation
|
||||
BSON.Binary = Binary;
|
||||
BSON.Code = Code;
|
||||
BSON.DBRef = DBRef;
|
||||
BSON.Decimal128 = Decimal128;
|
||||
BSON.Double = Double;
|
||||
BSON.Int32 = Int32;
|
||||
BSON.Long = Long;
|
||||
BSON.Map = Map;
|
||||
BSON.MaxKey = MaxKey;
|
||||
BSON.MinKey = MinKey;
|
||||
BSON.ObjectId = ObjectId;
|
||||
BSON.ObjectID = ObjectId;
|
||||
BSON.BSONRegExp = BSONRegExp;
|
||||
BSON.Symbol = Symbol;
|
||||
BSON.Timestamp = Timestamp;
|
||||
|
||||
// Return the BSON
|
||||
module.exports = BSON;
|
||||
+382
@@ -0,0 +1,382 @@
|
||||
/**
|
||||
* Module dependencies.
|
||||
* @ignore
|
||||
*/
|
||||
|
||||
// Test if we're in Node via presence of "global" not absence of "window"
|
||||
// to support hybrid environments like Electron
|
||||
if (typeof global !== 'undefined') {
|
||||
var Buffer = require('buffer').Buffer; // TODO just use global Buffer
|
||||
}
|
||||
|
||||
/**
|
||||
* A class representation of the BSON Binary type.
|
||||
*
|
||||
* Sub types
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_DEFAULT**, default BSON type.
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_FUNCTION**, BSON function type.
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY**, BSON byte array type.
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_UUID**, BSON uuid type.
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_MD5**, BSON md5 type.
|
||||
* - **BSON.BSON_BINARY_SUBTYPE_USER_DEFINED**, BSON user defined type.
|
||||
*
|
||||
* @class
|
||||
* @param {Buffer} buffer a buffer object containing the binary data.
|
||||
* @param {Number} [subType] the option binary type.
|
||||
* @return {Binary}
|
||||
*/
|
||||
function Binary(buffer, subType) {
|
||||
if (!(this instanceof Binary)) return new Binary(buffer, subType);
|
||||
|
||||
if (
|
||||
buffer != null &&
|
||||
!(typeof buffer === 'string') &&
|
||||
!Buffer.isBuffer(buffer) &&
|
||||
!(buffer instanceof Uint8Array) &&
|
||||
!Array.isArray(buffer)
|
||||
) {
|
||||
throw new Error('only String, Buffer, Uint8Array or Array accepted');
|
||||
}
|
||||
|
||||
this._bsontype = 'Binary';
|
||||
|
||||
if (buffer instanceof Number) {
|
||||
this.sub_type = buffer;
|
||||
this.position = 0;
|
||||
} else {
|
||||
this.sub_type = subType == null ? BSON_BINARY_SUBTYPE_DEFAULT : subType;
|
||||
this.position = 0;
|
||||
}
|
||||
|
||||
if (buffer != null && !(buffer instanceof Number)) {
|
||||
// Only accept Buffer, Uint8Array or Arrays
|
||||
if (typeof buffer === 'string') {
|
||||
// Different ways of writing the length of the string for the different types
|
||||
if (typeof Buffer !== 'undefined') {
|
||||
this.buffer = new Buffer(buffer);
|
||||
} else if (
|
||||
typeof Uint8Array !== 'undefined' ||
|
||||
Object.prototype.toString.call(buffer) === '[object Array]'
|
||||
) {
|
||||
this.buffer = writeStringToArray(buffer);
|
||||
} else {
|
||||
throw new Error('only String, Buffer, Uint8Array or Array accepted');
|
||||
}
|
||||
} else {
|
||||
this.buffer = buffer;
|
||||
}
|
||||
this.position = buffer.length;
|
||||
} else {
|
||||
if (typeof Buffer !== 'undefined') {
|
||||
this.buffer = new Buffer(Binary.BUFFER_SIZE);
|
||||
} else if (typeof Uint8Array !== 'undefined') {
|
||||
this.buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE));
|
||||
} else {
|
||||
this.buffer = new Array(Binary.BUFFER_SIZE);
|
||||
}
|
||||
// Set position to start of buffer
|
||||
this.position = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Updates this binary with byte_value.
|
||||
*
|
||||
* @method
|
||||
* @param {string} byte_value a single byte we wish to write.
|
||||
*/
|
||||
Binary.prototype.put = function put(byte_value) {
|
||||
// If it's a string and a has more than one character throw an error
|
||||
if (byte_value['length'] != null && typeof byte_value !== 'number' && byte_value.length !== 1)
|
||||
throw new Error('only accepts single character String, Uint8Array or Array');
|
||||
if ((typeof byte_value !== 'number' && byte_value < 0) || byte_value > 255)
|
||||
throw new Error('only accepts number in a valid unsigned byte range 0-255');
|
||||
|
||||
// Decode the byte value once
|
||||
var decoded_byte = null;
|
||||
if (typeof byte_value === 'string') {
|
||||
decoded_byte = byte_value.charCodeAt(0);
|
||||
} else if (byte_value['length'] != null) {
|
||||
decoded_byte = byte_value[0];
|
||||
} else {
|
||||
decoded_byte = byte_value;
|
||||
}
|
||||
|
||||
if (this.buffer.length > this.position) {
|
||||
this.buffer[this.position++] = decoded_byte;
|
||||
} else {
|
||||
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(this.buffer)) {
|
||||
// Create additional overflow buffer
|
||||
var buffer = new Buffer(Binary.BUFFER_SIZE + this.buffer.length);
|
||||
// Combine the two buffers together
|
||||
this.buffer.copy(buffer, 0, 0, this.buffer.length);
|
||||
this.buffer = buffer;
|
||||
this.buffer[this.position++] = decoded_byte;
|
||||
} else {
|
||||
buffer = null;
|
||||
// Create a new buffer (typed or normal array)
|
||||
if (Object.prototype.toString.call(this.buffer) === '[object Uint8Array]') {
|
||||
buffer = new Uint8Array(new ArrayBuffer(Binary.BUFFER_SIZE + this.buffer.length));
|
||||
} else {
|
||||
buffer = new Array(Binary.BUFFER_SIZE + this.buffer.length);
|
||||
}
|
||||
|
||||
// We need to copy all the content to the new array
|
||||
for (var i = 0; i < this.buffer.length; i++) {
|
||||
buffer[i] = this.buffer[i];
|
||||
}
|
||||
|
||||
// Reassign the buffer
|
||||
this.buffer = buffer;
|
||||
// Write the byte
|
||||
this.buffer[this.position++] = decoded_byte;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Writes a buffer or string to the binary.
|
||||
*
|
||||
* @method
|
||||
* @param {(Buffer|string)} string a string or buffer to be written to the Binary BSON object.
|
||||
* @param {number} offset specify the binary of where to write the content.
|
||||
* @return {null}
|
||||
*/
|
||||
Binary.prototype.write = function write(string, offset) {
|
||||
offset = typeof offset === 'number' ? offset : this.position;
|
||||
|
||||
// If the buffer is to small let's extend the buffer
|
||||
if (this.buffer.length < offset + string.length) {
|
||||
var buffer = null;
|
||||
// If we are in node.js
|
||||
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(this.buffer)) {
|
||||
buffer = new Buffer(this.buffer.length + string.length);
|
||||
this.buffer.copy(buffer, 0, 0, this.buffer.length);
|
||||
} else if (Object.prototype.toString.call(this.buffer) === '[object Uint8Array]') {
|
||||
// Create a new buffer
|
||||
buffer = new Uint8Array(new ArrayBuffer(this.buffer.length + string.length));
|
||||
// Copy the content
|
||||
for (var i = 0; i < this.position; i++) {
|
||||
buffer[i] = this.buffer[i];
|
||||
}
|
||||
}
|
||||
|
||||
// Assign the new buffer
|
||||
this.buffer = buffer;
|
||||
}
|
||||
|
||||
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(string) && Buffer.isBuffer(this.buffer)) {
|
||||
string.copy(this.buffer, offset, 0, string.length);
|
||||
this.position = offset + string.length > this.position ? offset + string.length : this.position;
|
||||
// offset = string.length
|
||||
} else if (
|
||||
typeof Buffer !== 'undefined' &&
|
||||
typeof string === 'string' &&
|
||||
Buffer.isBuffer(this.buffer)
|
||||
) {
|
||||
this.buffer.write(string, offset, 'binary');
|
||||
this.position = offset + string.length > this.position ? offset + string.length : this.position;
|
||||
// offset = string.length;
|
||||
} else if (
|
||||
Object.prototype.toString.call(string) === '[object Uint8Array]' ||
|
||||
(Object.prototype.toString.call(string) === '[object Array]' && typeof string !== 'string')
|
||||
) {
|
||||
for (i = 0; i < string.length; i++) {
|
||||
this.buffer[offset++] = string[i];
|
||||
}
|
||||
|
||||
this.position = offset > this.position ? offset : this.position;
|
||||
} else if (typeof string === 'string') {
|
||||
for (i = 0; i < string.length; i++) {
|
||||
this.buffer[offset++] = string.charCodeAt(i);
|
||||
}
|
||||
|
||||
this.position = offset > this.position ? offset : this.position;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Reads **length** bytes starting at **position**.
|
||||
*
|
||||
* @method
|
||||
* @param {number} position read from the given position in the Binary.
|
||||
* @param {number} length the number of bytes to read.
|
||||
* @return {Buffer}
|
||||
*/
|
||||
Binary.prototype.read = function read(position, length) {
|
||||
length = length && length > 0 ? length : this.position;
|
||||
|
||||
// Let's return the data based on the type we have
|
||||
if (this.buffer['slice']) {
|
||||
return this.buffer.slice(position, position + length);
|
||||
} else {
|
||||
// Create a buffer to keep the result
|
||||
var buffer =
|
||||
typeof Uint8Array !== 'undefined'
|
||||
? new Uint8Array(new ArrayBuffer(length))
|
||||
: new Array(length);
|
||||
for (var i = 0; i < length; i++) {
|
||||
buffer[i] = this.buffer[position++];
|
||||
}
|
||||
}
|
||||
// Return the buffer
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the value of this binary as a string.
|
||||
*
|
||||
* @method
|
||||
* @return {string}
|
||||
*/
|
||||
Binary.prototype.value = function value(asRaw) {
|
||||
asRaw = asRaw == null ? false : asRaw;
|
||||
|
||||
// Optimize to serialize for the situation where the data == size of buffer
|
||||
if (
|
||||
asRaw &&
|
||||
typeof Buffer !== 'undefined' &&
|
||||
Buffer.isBuffer(this.buffer) &&
|
||||
this.buffer.length === this.position
|
||||
)
|
||||
return this.buffer;
|
||||
|
||||
// If it's a node.js buffer object
|
||||
if (typeof Buffer !== 'undefined' && Buffer.isBuffer(this.buffer)) {
|
||||
return asRaw
|
||||
? this.buffer.slice(0, this.position)
|
||||
: this.buffer.toString('binary', 0, this.position);
|
||||
} else {
|
||||
if (asRaw) {
|
||||
// we support the slice command use it
|
||||
if (this.buffer['slice'] != null) {
|
||||
return this.buffer.slice(0, this.position);
|
||||
} else {
|
||||
// Create a new buffer to copy content to
|
||||
var newBuffer =
|
||||
Object.prototype.toString.call(this.buffer) === '[object Uint8Array]'
|
||||
? new Uint8Array(new ArrayBuffer(this.position))
|
||||
: new Array(this.position);
|
||||
// Copy content
|
||||
for (var i = 0; i < this.position; i++) {
|
||||
newBuffer[i] = this.buffer[i];
|
||||
}
|
||||
// Return the buffer
|
||||
return newBuffer;
|
||||
}
|
||||
} else {
|
||||
return convertArraytoUtf8BinaryString(this.buffer, 0, this.position);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Length.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the length of the binary.
|
||||
*/
|
||||
Binary.prototype.length = function length() {
|
||||
return this.position;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Binary.prototype.toJSON = function() {
|
||||
return this.buffer != null ? this.buffer.toString('base64') : '';
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Binary.prototype.toString = function(format) {
|
||||
return this.buffer != null ? this.buffer.slice(0, this.position).toString(format) : '';
|
||||
};
|
||||
|
||||
/**
|
||||
* Binary default subtype
|
||||
* @ignore
|
||||
*/
|
||||
var BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
var writeStringToArray = function(data) {
|
||||
// Create a buffer
|
||||
var buffer =
|
||||
typeof Uint8Array !== 'undefined'
|
||||
? new Uint8Array(new ArrayBuffer(data.length))
|
||||
: new Array(data.length);
|
||||
// Write the content to the buffer
|
||||
for (var i = 0; i < data.length; i++) {
|
||||
buffer[i] = data.charCodeAt(i);
|
||||
}
|
||||
// Write the string to the buffer
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Convert Array ot Uint8Array to Binary String
|
||||
*
|
||||
* @ignore
|
||||
*/
|
||||
var convertArraytoUtf8BinaryString = function(byteArray, startIndex, endIndex) {
|
||||
var result = '';
|
||||
for (var i = startIndex; i < endIndex; i++) {
|
||||
result = result + String.fromCharCode(byteArray[i]);
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
Binary.BUFFER_SIZE = 256;
|
||||
|
||||
/**
|
||||
* Default BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_DEFAULT = 0;
|
||||
/**
|
||||
* Function BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_FUNCTION = 1;
|
||||
/**
|
||||
* Byte Array BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_BYTE_ARRAY = 2;
|
||||
/**
|
||||
* OLD UUID BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_UUID_OLD = 3;
|
||||
/**
|
||||
* UUID BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_UUID = 4;
|
||||
/**
|
||||
* MD5 BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_MD5 = 5;
|
||||
/**
|
||||
* User BSON type
|
||||
*
|
||||
* @classconstant SUBTYPE_DEFAULT
|
||||
**/
|
||||
Binary.SUBTYPE_USER_DEFINED = 128;
|
||||
|
||||
/**
|
||||
* Expose.
|
||||
*/
|
||||
module.exports = Binary;
|
||||
module.exports.Binary = Binary;
|
||||
+385
@@ -0,0 +1,385 @@
|
||||
'use strict';
|
||||
|
||||
var Map = require('./map'),
|
||||
Long = require('./long'),
|
||||
Double = require('./double'),
|
||||
Timestamp = require('./timestamp'),
|
||||
ObjectID = require('./objectid'),
|
||||
BSONRegExp = require('./regexp'),
|
||||
Symbol = require('./symbol'),
|
||||
Int32 = require('./int_32'),
|
||||
Code = require('./code'),
|
||||
Decimal128 = require('./decimal128'),
|
||||
MinKey = require('./min_key'),
|
||||
MaxKey = require('./max_key'),
|
||||
DBRef = require('./db_ref'),
|
||||
Binary = require('./binary');
|
||||
|
||||
// Parts of the parser
|
||||
var deserialize = require('./parser/deserializer'),
|
||||
serializer = require('./parser/serializer'),
|
||||
calculateObjectSize = require('./parser/calculate_size');
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
// Default Max Size
|
||||
var MAXSIZE = 1024 * 1024 * 17;
|
||||
|
||||
// Current Internal Temporary Serialization Buffer
|
||||
var buffer = new Buffer(MAXSIZE);
|
||||
|
||||
var BSON = function() {};
|
||||
|
||||
/**
|
||||
* Serialize a Javascript object.
|
||||
*
|
||||
* @param {Object} object the Javascript object to serialize.
|
||||
* @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.
|
||||
* @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.
|
||||
* @param {Number} [options.minInternalBufferSize=1024*1024*17] minimum size of the internal temporary serialization buffer **(default:1024*1024*17)**.
|
||||
* @return {Buffer} returns the Buffer object containing the serialized object.
|
||||
* @api public
|
||||
*/
|
||||
BSON.prototype.serialize = function serialize(object, options) {
|
||||
options = options || {};
|
||||
// Unpack the options
|
||||
var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;
|
||||
var serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
var ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
||||
var minInternalBufferSize =
|
||||
typeof options.minInternalBufferSize === 'number' ? options.minInternalBufferSize : MAXSIZE;
|
||||
|
||||
// Resize the internal serialization buffer if needed
|
||||
if (buffer.length < minInternalBufferSize) {
|
||||
buffer = new Buffer(minInternalBufferSize);
|
||||
}
|
||||
|
||||
// Attempt to serialize
|
||||
var serializationIndex = serializer(
|
||||
buffer,
|
||||
object,
|
||||
checkKeys,
|
||||
0,
|
||||
0,
|
||||
serializeFunctions,
|
||||
ignoreUndefined,
|
||||
[]
|
||||
);
|
||||
// Create the final buffer
|
||||
var finishedBuffer = new Buffer(serializationIndex);
|
||||
// Copy into the finished buffer
|
||||
buffer.copy(finishedBuffer, 0, 0, finishedBuffer.length);
|
||||
// Return the buffer
|
||||
return finishedBuffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Serialize a Javascript object using a predefined Buffer and index into the buffer, useful when pre-allocating the space for serialization.
|
||||
*
|
||||
* @param {Object} object the Javascript object to serialize.
|
||||
* @param {Buffer} buffer the Buffer you pre-allocated to store the serialized BSON object.
|
||||
* @param {Boolean} [options.checkKeys] the serializer will check if keys are valid.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.
|
||||
* @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.
|
||||
* @param {Number} [options.index] the index in the buffer where we wish to start serializing into.
|
||||
* @return {Number} returns the index pointing to the last written byte in the buffer.
|
||||
* @api public
|
||||
*/
|
||||
BSON.prototype.serializeWithBufferAndIndex = function(object, finalBuffer, options) {
|
||||
options = options || {};
|
||||
// Unpack the options
|
||||
var checkKeys = typeof options.checkKeys === 'boolean' ? options.checkKeys : false;
|
||||
var serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
var ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
||||
var startIndex = typeof options.index === 'number' ? options.index : 0;
|
||||
|
||||
// Attempt to serialize
|
||||
var serializationIndex = serializer(
|
||||
finalBuffer,
|
||||
object,
|
||||
checkKeys,
|
||||
startIndex || 0,
|
||||
0,
|
||||
serializeFunctions,
|
||||
ignoreUndefined
|
||||
);
|
||||
|
||||
// Return the index
|
||||
return serializationIndex - 1;
|
||||
};
|
||||
|
||||
/**
|
||||
* Deserialize data as BSON.
|
||||
*
|
||||
* @param {Buffer} buffer the buffer containing the serialized set of BSON documents.
|
||||
* @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.
|
||||
* @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.
|
||||
* @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.
|
||||
* @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
||||
* @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.
|
||||
* @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.
|
||||
* @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.
|
||||
* @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.
|
||||
* @return {Object} returns the deserialized Javascript Object.
|
||||
* @api public
|
||||
*/
|
||||
BSON.prototype.deserialize = function(buffer, options) {
|
||||
return deserialize(buffer, options);
|
||||
};
|
||||
|
||||
/**
|
||||
* Calculate the bson size for a passed in Javascript object.
|
||||
*
|
||||
* @param {Object} object the Javascript object to calculate the BSON byte size for.
|
||||
* @param {Boolean} [options.serializeFunctions=false] serialize the javascript functions **(default:false)**.
|
||||
* @param {Boolean} [options.ignoreUndefined=true] ignore undefined fields **(default:true)**.
|
||||
* @return {Number} returns the number of bytes the BSON object will take up.
|
||||
* @api public
|
||||
*/
|
||||
BSON.prototype.calculateObjectSize = function(object, options) {
|
||||
options = options || {};
|
||||
|
||||
var serializeFunctions =
|
||||
typeof options.serializeFunctions === 'boolean' ? options.serializeFunctions : false;
|
||||
var ignoreUndefined =
|
||||
typeof options.ignoreUndefined === 'boolean' ? options.ignoreUndefined : true;
|
||||
|
||||
return calculateObjectSize(object, serializeFunctions, ignoreUndefined);
|
||||
};
|
||||
|
||||
/**
|
||||
* Deserialize stream data as BSON documents.
|
||||
*
|
||||
* @param {Buffer} data the buffer containing the serialized set of BSON documents.
|
||||
* @param {Number} startIndex the start index in the data Buffer where the deserialization is to start.
|
||||
* @param {Number} numberOfDocuments number of documents to deserialize.
|
||||
* @param {Array} documents an array where to store the deserialized documents.
|
||||
* @param {Number} docStartIndex the index in the documents array from where to start inserting documents.
|
||||
* @param {Object} [options] additional options used for the deserialization.
|
||||
* @param {Object} [options.evalFunctions=false] evaluate functions in the BSON document scoped to the object deserialized.
|
||||
* @param {Object} [options.cacheFunctions=false] cache evaluated functions for reuse.
|
||||
* @param {Object} [options.cacheFunctionsCrc32=false] use a crc32 code for caching, otherwise use the string of the function.
|
||||
* @param {Object} [options.promoteLongs=true] when deserializing a Long will fit it into a Number if it's smaller than 53 bits
|
||||
* @param {Object} [options.promoteBuffers=false] when deserializing a Binary will return it as a node.js Buffer instance.
|
||||
* @param {Object} [options.promoteValues=false] when deserializing will promote BSON values to their Node.js closest equivalent types.
|
||||
* @param {Object} [options.fieldsAsRaw=null] allow to specify if there what fields we wish to return as unserialized raw buffer.
|
||||
* @param {Object} [options.bsonRegExp=false] return BSON regular expressions as BSONRegExp instances.
|
||||
* @return {Number} returns the next index in the buffer after deserialization **x** numbers of documents.
|
||||
* @api public
|
||||
*/
|
||||
BSON.prototype.deserializeStream = function(
|
||||
data,
|
||||
startIndex,
|
||||
numberOfDocuments,
|
||||
documents,
|
||||
docStartIndex,
|
||||
options
|
||||
) {
|
||||
options = options != null ? options : {};
|
||||
var index = startIndex;
|
||||
// Loop over all documents
|
||||
for (var i = 0; i < numberOfDocuments; i++) {
|
||||
// Find size of the document
|
||||
var size =
|
||||
data[index] | (data[index + 1] << 8) | (data[index + 2] << 16) | (data[index + 3] << 24);
|
||||
// Update options with index
|
||||
options['index'] = index;
|
||||
// Parse the document at this point
|
||||
documents[docStartIndex + i] = this.deserialize(data, options);
|
||||
// Adjust index by the document size
|
||||
index = index + size;
|
||||
}
|
||||
|
||||
// Return object containing end index of parsing and list of documents
|
||||
return index;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
// BSON MAX VALUES
|
||||
BSON.BSON_INT32_MAX = 0x7fffffff;
|
||||
BSON.BSON_INT32_MIN = -0x80000000;
|
||||
|
||||
BSON.BSON_INT64_MAX = Math.pow(2, 63) - 1;
|
||||
BSON.BSON_INT64_MIN = -Math.pow(2, 63);
|
||||
|
||||
// JS MAX PRECISE VALUES
|
||||
BSON.JS_INT_MAX = 0x20000000000000; // Any integer up to 2^53 can be precisely represented by a double.
|
||||
BSON.JS_INT_MIN = -0x20000000000000; // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
// Internal long versions
|
||||
// var JS_INT_MAX_LONG = Long.fromNumber(0x20000000000000); // Any integer up to 2^53 can be precisely represented by a double.
|
||||
// var JS_INT_MIN_LONG = Long.fromNumber(-0x20000000000000); // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
/**
|
||||
* Number BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_NUMBER
|
||||
**/
|
||||
BSON.BSON_DATA_NUMBER = 1;
|
||||
/**
|
||||
* String BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_STRING
|
||||
**/
|
||||
BSON.BSON_DATA_STRING = 2;
|
||||
/**
|
||||
* Object BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_OBJECT
|
||||
**/
|
||||
BSON.BSON_DATA_OBJECT = 3;
|
||||
/**
|
||||
* Array BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_ARRAY
|
||||
**/
|
||||
BSON.BSON_DATA_ARRAY = 4;
|
||||
/**
|
||||
* Binary BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_BINARY
|
||||
**/
|
||||
BSON.BSON_DATA_BINARY = 5;
|
||||
/**
|
||||
* ObjectID BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_OID
|
||||
**/
|
||||
BSON.BSON_DATA_OID = 7;
|
||||
/**
|
||||
* Boolean BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_BOOLEAN
|
||||
**/
|
||||
BSON.BSON_DATA_BOOLEAN = 8;
|
||||
/**
|
||||
* Date BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_DATE
|
||||
**/
|
||||
BSON.BSON_DATA_DATE = 9;
|
||||
/**
|
||||
* null BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_NULL
|
||||
**/
|
||||
BSON.BSON_DATA_NULL = 10;
|
||||
/**
|
||||
* RegExp BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_REGEXP
|
||||
**/
|
||||
BSON.BSON_DATA_REGEXP = 11;
|
||||
/**
|
||||
* Code BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_CODE
|
||||
**/
|
||||
BSON.BSON_DATA_CODE = 13;
|
||||
/**
|
||||
* Symbol BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_SYMBOL
|
||||
**/
|
||||
BSON.BSON_DATA_SYMBOL = 14;
|
||||
/**
|
||||
* Code with Scope BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_CODE_W_SCOPE
|
||||
**/
|
||||
BSON.BSON_DATA_CODE_W_SCOPE = 15;
|
||||
/**
|
||||
* 32 bit Integer BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_INT
|
||||
**/
|
||||
BSON.BSON_DATA_INT = 16;
|
||||
/**
|
||||
* Timestamp BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_TIMESTAMP
|
||||
**/
|
||||
BSON.BSON_DATA_TIMESTAMP = 17;
|
||||
/**
|
||||
* Long BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_LONG
|
||||
**/
|
||||
BSON.BSON_DATA_LONG = 18;
|
||||
/**
|
||||
* MinKey BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_MIN_KEY
|
||||
**/
|
||||
BSON.BSON_DATA_MIN_KEY = 0xff;
|
||||
/**
|
||||
* MaxKey BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_MAX_KEY
|
||||
**/
|
||||
BSON.BSON_DATA_MAX_KEY = 0x7f;
|
||||
|
||||
/**
|
||||
* Binary Default Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_DEFAULT
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
||||
/**
|
||||
* Binary Function Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_FUNCTION
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_FUNCTION = 1;
|
||||
/**
|
||||
* Binary Byte Array Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
|
||||
/**
|
||||
* Binary UUID Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_UUID
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_UUID = 3;
|
||||
/**
|
||||
* Binary MD5 Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_MD5
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_MD5 = 4;
|
||||
/**
|
||||
* Binary User Defined Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
|
||||
|
||||
// Return BSON
|
||||
module.exports = BSON;
|
||||
module.exports.Code = Code;
|
||||
module.exports.Map = Map;
|
||||
module.exports.Symbol = Symbol;
|
||||
module.exports.BSON = BSON;
|
||||
module.exports.DBRef = DBRef;
|
||||
module.exports.Binary = Binary;
|
||||
module.exports.ObjectID = ObjectID;
|
||||
module.exports.Long = Long;
|
||||
module.exports.Timestamp = Timestamp;
|
||||
module.exports.Double = Double;
|
||||
module.exports.Int32 = Int32;
|
||||
module.exports.MinKey = MinKey;
|
||||
module.exports.MaxKey = MaxKey;
|
||||
module.exports.BSONRegExp = BSONRegExp;
|
||||
module.exports.Decimal128 = Decimal128;
|
||||
+24
@@ -0,0 +1,24 @@
|
||||
/**
|
||||
* A class representation of the BSON Code type.
|
||||
*
|
||||
* @class
|
||||
* @param {(string|function)} code a string or function.
|
||||
* @param {Object} [scope] an optional scope for the function.
|
||||
* @return {Code}
|
||||
*/
|
||||
var Code = function Code(code, scope) {
|
||||
if (!(this instanceof Code)) return new Code(code, scope);
|
||||
this._bsontype = 'Code';
|
||||
this.code = code;
|
||||
this.scope = scope;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Code.prototype.toJSON = function() {
|
||||
return { scope: this.scope, code: this.code };
|
||||
};
|
||||
|
||||
module.exports = Code;
|
||||
module.exports.Code = Code;
|
||||
+32
@@ -0,0 +1,32 @@
|
||||
/**
|
||||
* A class representation of the BSON DBRef type.
|
||||
*
|
||||
* @class
|
||||
* @param {string} namespace the collection name.
|
||||
* @param {ObjectID} oid the reference ObjectID.
|
||||
* @param {string} [db] optional db name, if omitted the reference is local to the current db.
|
||||
* @return {DBRef}
|
||||
*/
|
||||
function DBRef(namespace, oid, db) {
|
||||
if (!(this instanceof DBRef)) return new DBRef(namespace, oid, db);
|
||||
|
||||
this._bsontype = 'DBRef';
|
||||
this.namespace = namespace;
|
||||
this.oid = oid;
|
||||
this.db = db;
|
||||
}
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
DBRef.prototype.toJSON = function() {
|
||||
return {
|
||||
$ref: this.namespace,
|
||||
$id: this.oid,
|
||||
$db: this.db == null ? '' : this.db
|
||||
};
|
||||
};
|
||||
|
||||
module.exports = DBRef;
|
||||
module.exports.DBRef = DBRef;
|
||||
+818
@@ -0,0 +1,818 @@
|
||||
'use strict';
|
||||
|
||||
var Long = require('./long');
|
||||
|
||||
var PARSE_STRING_REGEXP = /^(\+|-)?(\d+|(\d*\.\d*))?(E|e)?([-+])?(\d+)?$/;
|
||||
var PARSE_INF_REGEXP = /^(\+|-)?(Infinity|inf)$/i;
|
||||
var PARSE_NAN_REGEXP = /^(\+|-)?NaN$/i;
|
||||
|
||||
var EXPONENT_MAX = 6111;
|
||||
var EXPONENT_MIN = -6176;
|
||||
var EXPONENT_BIAS = 6176;
|
||||
var MAX_DIGITS = 34;
|
||||
|
||||
// Nan value bits as 32 bit values (due to lack of longs)
|
||||
var NAN_BUFFER = [
|
||||
0x7c,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00
|
||||
].reverse();
|
||||
// Infinity value bits 32 bit values (due to lack of longs)
|
||||
var INF_NEGATIVE_BUFFER = [
|
||||
0xf8,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00
|
||||
].reverse();
|
||||
var INF_POSITIVE_BUFFER = [
|
||||
0x78,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00,
|
||||
0x00
|
||||
].reverse();
|
||||
|
||||
var EXPONENT_REGEX = /^([-+])?(\d+)?$/;
|
||||
|
||||
// Detect if the value is a digit
|
||||
var isDigit = function(value) {
|
||||
return !isNaN(parseInt(value, 10));
|
||||
};
|
||||
|
||||
// Divide two uint128 values
|
||||
var divideu128 = function(value) {
|
||||
var DIVISOR = Long.fromNumber(1000 * 1000 * 1000);
|
||||
var _rem = Long.fromNumber(0);
|
||||
var i = 0;
|
||||
|
||||
if (!value.parts[0] && !value.parts[1] && !value.parts[2] && !value.parts[3]) {
|
||||
return { quotient: value, rem: _rem };
|
||||
}
|
||||
|
||||
for (i = 0; i <= 3; i++) {
|
||||
// Adjust remainder to match value of next dividend
|
||||
_rem = _rem.shiftLeft(32);
|
||||
// Add the divided to _rem
|
||||
_rem = _rem.add(new Long(value.parts[i], 0));
|
||||
value.parts[i] = _rem.div(DIVISOR).low_;
|
||||
_rem = _rem.modulo(DIVISOR);
|
||||
}
|
||||
|
||||
return { quotient: value, rem: _rem };
|
||||
};
|
||||
|
||||
// Multiply two Long values and return the 128 bit value
|
||||
var multiply64x2 = function(left, right) {
|
||||
if (!left && !right) {
|
||||
return { high: Long.fromNumber(0), low: Long.fromNumber(0) };
|
||||
}
|
||||
|
||||
var leftHigh = left.shiftRightUnsigned(32);
|
||||
var leftLow = new Long(left.getLowBits(), 0);
|
||||
var rightHigh = right.shiftRightUnsigned(32);
|
||||
var rightLow = new Long(right.getLowBits(), 0);
|
||||
|
||||
var productHigh = leftHigh.multiply(rightHigh);
|
||||
var productMid = leftHigh.multiply(rightLow);
|
||||
var productMid2 = leftLow.multiply(rightHigh);
|
||||
var productLow = leftLow.multiply(rightLow);
|
||||
|
||||
productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
|
||||
productMid = new Long(productMid.getLowBits(), 0)
|
||||
.add(productMid2)
|
||||
.add(productLow.shiftRightUnsigned(32));
|
||||
|
||||
productHigh = productHigh.add(productMid.shiftRightUnsigned(32));
|
||||
productLow = productMid.shiftLeft(32).add(new Long(productLow.getLowBits(), 0));
|
||||
|
||||
// Return the 128 bit result
|
||||
return { high: productHigh, low: productLow };
|
||||
};
|
||||
|
||||
var lessThan = function(left, right) {
|
||||
// Make values unsigned
|
||||
var uhleft = left.high_ >>> 0;
|
||||
var uhright = right.high_ >>> 0;
|
||||
|
||||
// Compare high bits first
|
||||
if (uhleft < uhright) {
|
||||
return true;
|
||||
} else if (uhleft === uhright) {
|
||||
var ulleft = left.low_ >>> 0;
|
||||
var ulright = right.low_ >>> 0;
|
||||
if (ulleft < ulright) return true;
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
// var longtoHex = function(value) {
|
||||
// var buffer = new Buffer(8);
|
||||
// var index = 0;
|
||||
// // Encode the low 64 bits of the decimal
|
||||
// // Encode low bits
|
||||
// buffer[index++] = value.low_ & 0xff;
|
||||
// buffer[index++] = (value.low_ >> 8) & 0xff;
|
||||
// buffer[index++] = (value.low_ >> 16) & 0xff;
|
||||
// buffer[index++] = (value.low_ >> 24) & 0xff;
|
||||
// // Encode high bits
|
||||
// buffer[index++] = value.high_ & 0xff;
|
||||
// buffer[index++] = (value.high_ >> 8) & 0xff;
|
||||
// buffer[index++] = (value.high_ >> 16) & 0xff;
|
||||
// buffer[index++] = (value.high_ >> 24) & 0xff;
|
||||
// return buffer.reverse().toString('hex');
|
||||
// };
|
||||
|
||||
// var int32toHex = function(value) {
|
||||
// var buffer = new Buffer(4);
|
||||
// var index = 0;
|
||||
// // Encode the low 64 bits of the decimal
|
||||
// // Encode low bits
|
||||
// buffer[index++] = value & 0xff;
|
||||
// buffer[index++] = (value >> 8) & 0xff;
|
||||
// buffer[index++] = (value >> 16) & 0xff;
|
||||
// buffer[index++] = (value >> 24) & 0xff;
|
||||
// return buffer.reverse().toString('hex');
|
||||
// };
|
||||
|
||||
/**
|
||||
* A class representation of the BSON Decimal128 type.
|
||||
*
|
||||
* @class
|
||||
* @param {Buffer} bytes a buffer containing the raw Decimal128 bytes.
|
||||
* @return {Double}
|
||||
*/
|
||||
var Decimal128 = function(bytes) {
|
||||
this._bsontype = 'Decimal128';
|
||||
this.bytes = bytes;
|
||||
};
|
||||
|
||||
/**
|
||||
* Create a Decimal128 instance from a string representation
|
||||
*
|
||||
* @method
|
||||
* @param {string} string a numeric string representation.
|
||||
* @return {Decimal128} returns a Decimal128 instance.
|
||||
*/
|
||||
Decimal128.fromString = function(string) {
|
||||
// Parse state tracking
|
||||
var isNegative = false;
|
||||
var sawRadix = false;
|
||||
var foundNonZero = false;
|
||||
|
||||
// Total number of significant digits (no leading or trailing zero)
|
||||
var significantDigits = 0;
|
||||
// Total number of significand digits read
|
||||
var nDigitsRead = 0;
|
||||
// Total number of digits (no leading zeros)
|
||||
var nDigits = 0;
|
||||
// The number of the digits after radix
|
||||
var radixPosition = 0;
|
||||
// The index of the first non-zero in *str*
|
||||
var firstNonZero = 0;
|
||||
|
||||
// Digits Array
|
||||
var digits = [0];
|
||||
// The number of digits in digits
|
||||
var nDigitsStored = 0;
|
||||
// Insertion pointer for digits
|
||||
var digitsInsert = 0;
|
||||
// The index of the first non-zero digit
|
||||
var firstDigit = 0;
|
||||
// The index of the last digit
|
||||
var lastDigit = 0;
|
||||
|
||||
// Exponent
|
||||
var exponent = 0;
|
||||
// loop index over array
|
||||
var i = 0;
|
||||
// The high 17 digits of the significand
|
||||
var significandHigh = [0, 0];
|
||||
// The low 17 digits of the significand
|
||||
var significandLow = [0, 0];
|
||||
// The biased exponent
|
||||
var biasedExponent = 0;
|
||||
|
||||
// Read index
|
||||
var index = 0;
|
||||
|
||||
// Trim the string
|
||||
string = string.trim();
|
||||
|
||||
// Naively prevent against REDOS attacks.
|
||||
// TODO: implementing a custom parsing for this, or refactoring the regex would yield
|
||||
// further gains.
|
||||
if (string.length >= 7000) {
|
||||
throw new Error('' + string + ' not a valid Decimal128 string');
|
||||
}
|
||||
|
||||
// Results
|
||||
var stringMatch = string.match(PARSE_STRING_REGEXP);
|
||||
var infMatch = string.match(PARSE_INF_REGEXP);
|
||||
var nanMatch = string.match(PARSE_NAN_REGEXP);
|
||||
|
||||
// Validate the string
|
||||
if ((!stringMatch && !infMatch && !nanMatch) || string.length === 0) {
|
||||
throw new Error('' + string + ' not a valid Decimal128 string');
|
||||
}
|
||||
|
||||
// Check if we have an illegal exponent format
|
||||
if (stringMatch && stringMatch[4] && stringMatch[2] === undefined) {
|
||||
throw new Error('' + string + ' not a valid Decimal128 string');
|
||||
}
|
||||
|
||||
// Get the negative or positive sign
|
||||
if (string[index] === '+' || string[index] === '-') {
|
||||
isNegative = string[index++] === '-';
|
||||
}
|
||||
|
||||
// Check if user passed Infinity or NaN
|
||||
if (!isDigit(string[index]) && string[index] !== '.') {
|
||||
if (string[index] === 'i' || string[index] === 'I') {
|
||||
return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
|
||||
} else if (string[index] === 'N') {
|
||||
return new Decimal128(new Buffer(NAN_BUFFER));
|
||||
}
|
||||
}
|
||||
|
||||
// Read all the digits
|
||||
while (isDigit(string[index]) || string[index] === '.') {
|
||||
if (string[index] === '.') {
|
||||
if (sawRadix) {
|
||||
return new Decimal128(new Buffer(NAN_BUFFER));
|
||||
}
|
||||
|
||||
sawRadix = true;
|
||||
index = index + 1;
|
||||
continue;
|
||||
}
|
||||
|
||||
if (nDigitsStored < 34) {
|
||||
if (string[index] !== '0' || foundNonZero) {
|
||||
if (!foundNonZero) {
|
||||
firstNonZero = nDigitsRead;
|
||||
}
|
||||
|
||||
foundNonZero = true;
|
||||
|
||||
// Only store 34 digits
|
||||
digits[digitsInsert++] = parseInt(string[index], 10);
|
||||
nDigitsStored = nDigitsStored + 1;
|
||||
}
|
||||
}
|
||||
|
||||
if (foundNonZero) {
|
||||
nDigits = nDigits + 1;
|
||||
}
|
||||
|
||||
if (sawRadix) {
|
||||
radixPosition = radixPosition + 1;
|
||||
}
|
||||
|
||||
nDigitsRead = nDigitsRead + 1;
|
||||
index = index + 1;
|
||||
}
|
||||
|
||||
if (sawRadix && !nDigitsRead) {
|
||||
throw new Error('' + string + ' not a valid Decimal128 string');
|
||||
}
|
||||
|
||||
// Read exponent if exists
|
||||
if (string[index] === 'e' || string[index] === 'E') {
|
||||
// Read exponent digits
|
||||
var match = string.substr(++index).match(EXPONENT_REGEX);
|
||||
|
||||
// No digits read
|
||||
if (!match || !match[2]) {
|
||||
return new Decimal128(new Buffer(NAN_BUFFER));
|
||||
}
|
||||
|
||||
// Get exponent
|
||||
exponent = parseInt(match[0], 10);
|
||||
|
||||
// Adjust the index
|
||||
index = index + match[0].length;
|
||||
}
|
||||
|
||||
// Return not a number
|
||||
if (string[index]) {
|
||||
return new Decimal128(new Buffer(NAN_BUFFER));
|
||||
}
|
||||
|
||||
// Done reading input
|
||||
// Find first non-zero digit in digits
|
||||
firstDigit = 0;
|
||||
|
||||
if (!nDigitsStored) {
|
||||
firstDigit = 0;
|
||||
lastDigit = 0;
|
||||
digits[0] = 0;
|
||||
nDigits = 1;
|
||||
nDigitsStored = 1;
|
||||
significantDigits = 0;
|
||||
} else {
|
||||
lastDigit = nDigitsStored - 1;
|
||||
significantDigits = nDigits;
|
||||
|
||||
if (exponent !== 0 && significantDigits !== 1) {
|
||||
while (string[firstNonZero + significantDigits - 1] === '0') {
|
||||
significantDigits = significantDigits - 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Normalization of exponent
|
||||
// Correct exponent based on radix position, and shift significand as needed
|
||||
// to represent user input
|
||||
|
||||
// Overflow prevention
|
||||
if (exponent <= radixPosition && radixPosition - exponent > 1 << 14) {
|
||||
exponent = EXPONENT_MIN;
|
||||
} else {
|
||||
exponent = exponent - radixPosition;
|
||||
}
|
||||
|
||||
// Attempt to normalize the exponent
|
||||
while (exponent > EXPONENT_MAX) {
|
||||
// Shift exponent to significand and decrease
|
||||
lastDigit = lastDigit + 1;
|
||||
|
||||
if (lastDigit - firstDigit > MAX_DIGITS) {
|
||||
// Check if we have a zero then just hard clamp, otherwise fail
|
||||
var digitsString = digits.join('');
|
||||
if (digitsString.match(/^0+$/)) {
|
||||
exponent = EXPONENT_MAX;
|
||||
break;
|
||||
} else {
|
||||
return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
|
||||
}
|
||||
}
|
||||
|
||||
exponent = exponent - 1;
|
||||
}
|
||||
|
||||
while (exponent < EXPONENT_MIN || nDigitsStored < nDigits) {
|
||||
// Shift last digit
|
||||
if (lastDigit === 0) {
|
||||
exponent = EXPONENT_MIN;
|
||||
significantDigits = 0;
|
||||
break;
|
||||
}
|
||||
|
||||
if (nDigitsStored < nDigits) {
|
||||
// adjust to match digits not stored
|
||||
nDigits = nDigits - 1;
|
||||
} else {
|
||||
// adjust to round
|
||||
lastDigit = lastDigit - 1;
|
||||
}
|
||||
|
||||
if (exponent < EXPONENT_MAX) {
|
||||
exponent = exponent + 1;
|
||||
} else {
|
||||
// Check if we have a zero then just hard clamp, otherwise fail
|
||||
digitsString = digits.join('');
|
||||
if (digitsString.match(/^0+$/)) {
|
||||
exponent = EXPONENT_MAX;
|
||||
break;
|
||||
} else {
|
||||
return new Decimal128(new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Round
|
||||
// We've normalized the exponent, but might still need to round.
|
||||
if (lastDigit - firstDigit + 1 < significantDigits && string[significantDigits] !== '0') {
|
||||
var endOfString = nDigitsRead;
|
||||
|
||||
// If we have seen a radix point, 'string' is 1 longer than we have
|
||||
// documented with ndigits_read, so inc the position of the first nonzero
|
||||
// digit and the position that digits are read to.
|
||||
if (sawRadix && exponent === EXPONENT_MIN) {
|
||||
firstNonZero = firstNonZero + 1;
|
||||
endOfString = endOfString + 1;
|
||||
}
|
||||
|
||||
var roundDigit = parseInt(string[firstNonZero + lastDigit + 1], 10);
|
||||
var roundBit = 0;
|
||||
|
||||
if (roundDigit >= 5) {
|
||||
roundBit = 1;
|
||||
|
||||
if (roundDigit === 5) {
|
||||
roundBit = digits[lastDigit] % 2 === 1;
|
||||
|
||||
for (i = firstNonZero + lastDigit + 2; i < endOfString; i++) {
|
||||
if (parseInt(string[i], 10)) {
|
||||
roundBit = 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if (roundBit) {
|
||||
var dIdx = lastDigit;
|
||||
|
||||
for (; dIdx >= 0; dIdx--) {
|
||||
if (++digits[dIdx] > 9) {
|
||||
digits[dIdx] = 0;
|
||||
|
||||
// overflowed most significant digit
|
||||
if (dIdx === 0) {
|
||||
if (exponent < EXPONENT_MAX) {
|
||||
exponent = exponent + 1;
|
||||
digits[dIdx] = 1;
|
||||
} else {
|
||||
return new Decimal128(
|
||||
new Buffer(isNegative ? INF_NEGATIVE_BUFFER : INF_POSITIVE_BUFFER)
|
||||
);
|
||||
}
|
||||
}
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Encode significand
|
||||
// The high 17 digits of the significand
|
||||
significandHigh = Long.fromNumber(0);
|
||||
// The low 17 digits of the significand
|
||||
significandLow = Long.fromNumber(0);
|
||||
|
||||
// read a zero
|
||||
if (significantDigits === 0) {
|
||||
significandHigh = Long.fromNumber(0);
|
||||
significandLow = Long.fromNumber(0);
|
||||
} else if (lastDigit - firstDigit < 17) {
|
||||
dIdx = firstDigit;
|
||||
significandLow = Long.fromNumber(digits[dIdx++]);
|
||||
significandHigh = new Long(0, 0);
|
||||
|
||||
for (; dIdx <= lastDigit; dIdx++) {
|
||||
significandLow = significandLow.multiply(Long.fromNumber(10));
|
||||
significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
|
||||
}
|
||||
} else {
|
||||
dIdx = firstDigit;
|
||||
significandHigh = Long.fromNumber(digits[dIdx++]);
|
||||
|
||||
for (; dIdx <= lastDigit - 17; dIdx++) {
|
||||
significandHigh = significandHigh.multiply(Long.fromNumber(10));
|
||||
significandHigh = significandHigh.add(Long.fromNumber(digits[dIdx]));
|
||||
}
|
||||
|
||||
significandLow = Long.fromNumber(digits[dIdx++]);
|
||||
|
||||
for (; dIdx <= lastDigit; dIdx++) {
|
||||
significandLow = significandLow.multiply(Long.fromNumber(10));
|
||||
significandLow = significandLow.add(Long.fromNumber(digits[dIdx]));
|
||||
}
|
||||
}
|
||||
|
||||
var significand = multiply64x2(significandHigh, Long.fromString('100000000000000000'));
|
||||
|
||||
significand.low = significand.low.add(significandLow);
|
||||
|
||||
if (lessThan(significand.low, significandLow)) {
|
||||
significand.high = significand.high.add(Long.fromNumber(1));
|
||||
}
|
||||
|
||||
// Biased exponent
|
||||
biasedExponent = exponent + EXPONENT_BIAS;
|
||||
var dec = { low: Long.fromNumber(0), high: Long.fromNumber(0) };
|
||||
|
||||
// Encode combination, exponent, and significand.
|
||||
if (
|
||||
significand.high
|
||||
.shiftRightUnsigned(49)
|
||||
.and(Long.fromNumber(1))
|
||||
.equals(Long.fromNumber)
|
||||
) {
|
||||
// Encode '11' into bits 1 to 3
|
||||
dec.high = dec.high.or(Long.fromNumber(0x3).shiftLeft(61));
|
||||
dec.high = dec.high.or(
|
||||
Long.fromNumber(biasedExponent).and(Long.fromNumber(0x3fff).shiftLeft(47))
|
||||
);
|
||||
dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x7fffffffffff)));
|
||||
} else {
|
||||
dec.high = dec.high.or(Long.fromNumber(biasedExponent & 0x3fff).shiftLeft(49));
|
||||
dec.high = dec.high.or(significand.high.and(Long.fromNumber(0x1ffffffffffff)));
|
||||
}
|
||||
|
||||
dec.low = significand.low;
|
||||
|
||||
// Encode sign
|
||||
if (isNegative) {
|
||||
dec.high = dec.high.or(Long.fromString('9223372036854775808'));
|
||||
}
|
||||
|
||||
// Encode into a buffer
|
||||
var buffer = new Buffer(16);
|
||||
index = 0;
|
||||
|
||||
// Encode the low 64 bits of the decimal
|
||||
// Encode low bits
|
||||
buffer[index++] = dec.low.low_ & 0xff;
|
||||
buffer[index++] = (dec.low.low_ >> 8) & 0xff;
|
||||
buffer[index++] = (dec.low.low_ >> 16) & 0xff;
|
||||
buffer[index++] = (dec.low.low_ >> 24) & 0xff;
|
||||
// Encode high bits
|
||||
buffer[index++] = dec.low.high_ & 0xff;
|
||||
buffer[index++] = (dec.low.high_ >> 8) & 0xff;
|
||||
buffer[index++] = (dec.low.high_ >> 16) & 0xff;
|
||||
buffer[index++] = (dec.low.high_ >> 24) & 0xff;
|
||||
|
||||
// Encode the high 64 bits of the decimal
|
||||
// Encode low bits
|
||||
buffer[index++] = dec.high.low_ & 0xff;
|
||||
buffer[index++] = (dec.high.low_ >> 8) & 0xff;
|
||||
buffer[index++] = (dec.high.low_ >> 16) & 0xff;
|
||||
buffer[index++] = (dec.high.low_ >> 24) & 0xff;
|
||||
// Encode high bits
|
||||
buffer[index++] = dec.high.high_ & 0xff;
|
||||
buffer[index++] = (dec.high.high_ >> 8) & 0xff;
|
||||
buffer[index++] = (dec.high.high_ >> 16) & 0xff;
|
||||
buffer[index++] = (dec.high.high_ >> 24) & 0xff;
|
||||
|
||||
// Return the new Decimal128
|
||||
return new Decimal128(buffer);
|
||||
};
|
||||
|
||||
// Extract least significant 5 bits
|
||||
var COMBINATION_MASK = 0x1f;
|
||||
// Extract least significant 14 bits
|
||||
var EXPONENT_MASK = 0x3fff;
|
||||
// Value of combination field for Inf
|
||||
var COMBINATION_INFINITY = 30;
|
||||
// Value of combination field for NaN
|
||||
var COMBINATION_NAN = 31;
|
||||
// Value of combination field for NaN
|
||||
// var COMBINATION_SNAN = 32;
|
||||
// decimal128 exponent bias
|
||||
EXPONENT_BIAS = 6176;
|
||||
|
||||
/**
|
||||
* Create a string representation of the raw Decimal128 value
|
||||
*
|
||||
* @method
|
||||
* @return {string} returns a Decimal128 string representation.
|
||||
*/
|
||||
Decimal128.prototype.toString = function() {
|
||||
// Note: bits in this routine are referred to starting at 0,
|
||||
// from the sign bit, towards the coefficient.
|
||||
|
||||
// bits 0 - 31
|
||||
var high;
|
||||
// bits 32 - 63
|
||||
var midh;
|
||||
// bits 64 - 95
|
||||
var midl;
|
||||
// bits 96 - 127
|
||||
var low;
|
||||
// bits 1 - 5
|
||||
var combination;
|
||||
// decoded biased exponent (14 bits)
|
||||
var biased_exponent;
|
||||
// the number of significand digits
|
||||
var significand_digits = 0;
|
||||
// the base-10 digits in the significand
|
||||
var significand = new Array(36);
|
||||
for (var i = 0; i < significand.length; i++) significand[i] = 0;
|
||||
// read pointer into significand
|
||||
var index = 0;
|
||||
|
||||
// unbiased exponent
|
||||
var exponent;
|
||||
// the exponent if scientific notation is used
|
||||
var scientific_exponent;
|
||||
|
||||
// true if the number is zero
|
||||
var is_zero = false;
|
||||
|
||||
// the most signifcant significand bits (50-46)
|
||||
var significand_msb;
|
||||
// temporary storage for significand decoding
|
||||
var significand128 = { parts: new Array(4) };
|
||||
// indexing variables
|
||||
i;
|
||||
var j, k;
|
||||
|
||||
// Output string
|
||||
var string = [];
|
||||
|
||||
// Unpack index
|
||||
index = 0;
|
||||
|
||||
// Buffer reference
|
||||
var buffer = this.bytes;
|
||||
|
||||
// Unpack the low 64bits into a long
|
||||
low =
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
||||
midl =
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
||||
|
||||
// Unpack the high 64bits into a long
|
||||
midh =
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
||||
high =
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
||||
|
||||
// Unpack index
|
||||
index = 0;
|
||||
|
||||
// Create the state of the decimal
|
||||
var dec = {
|
||||
low: new Long(low, midl),
|
||||
high: new Long(midh, high)
|
||||
};
|
||||
|
||||
if (dec.high.lessThan(Long.ZERO)) {
|
||||
string.push('-');
|
||||
}
|
||||
|
||||
// Decode combination field and exponent
|
||||
combination = (high >> 26) & COMBINATION_MASK;
|
||||
|
||||
if (combination >> 3 === 3) {
|
||||
// Check for 'special' values
|
||||
if (combination === COMBINATION_INFINITY) {
|
||||
return string.join('') + 'Infinity';
|
||||
} else if (combination === COMBINATION_NAN) {
|
||||
return 'NaN';
|
||||
} else {
|
||||
biased_exponent = (high >> 15) & EXPONENT_MASK;
|
||||
significand_msb = 0x08 + ((high >> 14) & 0x01);
|
||||
}
|
||||
} else {
|
||||
significand_msb = (high >> 14) & 0x07;
|
||||
biased_exponent = (high >> 17) & EXPONENT_MASK;
|
||||
}
|
||||
|
||||
exponent = biased_exponent - EXPONENT_BIAS;
|
||||
|
||||
// Create string of significand digits
|
||||
|
||||
// Convert the 114-bit binary number represented by
|
||||
// (significand_high, significand_low) to at most 34 decimal
|
||||
// digits through modulo and division.
|
||||
significand128.parts[0] = (high & 0x3fff) + ((significand_msb & 0xf) << 14);
|
||||
significand128.parts[1] = midh;
|
||||
significand128.parts[2] = midl;
|
||||
significand128.parts[3] = low;
|
||||
|
||||
if (
|
||||
significand128.parts[0] === 0 &&
|
||||
significand128.parts[1] === 0 &&
|
||||
significand128.parts[2] === 0 &&
|
||||
significand128.parts[3] === 0
|
||||
) {
|
||||
is_zero = true;
|
||||
} else {
|
||||
for (k = 3; k >= 0; k--) {
|
||||
var least_digits = 0;
|
||||
// Peform the divide
|
||||
var result = divideu128(significand128);
|
||||
significand128 = result.quotient;
|
||||
least_digits = result.rem.low_;
|
||||
|
||||
// We now have the 9 least significant digits (in base 2).
|
||||
// Convert and output to string.
|
||||
if (!least_digits) continue;
|
||||
|
||||
for (j = 8; j >= 0; j--) {
|
||||
// significand[k * 9 + j] = Math.round(least_digits % 10);
|
||||
significand[k * 9 + j] = least_digits % 10;
|
||||
// least_digits = Math.round(least_digits / 10);
|
||||
least_digits = Math.floor(least_digits / 10);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// Output format options:
|
||||
// Scientific - [-]d.dddE(+/-)dd or [-]dE(+/-)dd
|
||||
// Regular - ddd.ddd
|
||||
|
||||
if (is_zero) {
|
||||
significand_digits = 1;
|
||||
significand[index] = 0;
|
||||
} else {
|
||||
significand_digits = 36;
|
||||
i = 0;
|
||||
|
||||
while (!significand[index]) {
|
||||
i++;
|
||||
significand_digits = significand_digits - 1;
|
||||
index = index + 1;
|
||||
}
|
||||
}
|
||||
|
||||
scientific_exponent = significand_digits - 1 + exponent;
|
||||
|
||||
// The scientific exponent checks are dictated by the string conversion
|
||||
// specification and are somewhat arbitrary cutoffs.
|
||||
//
|
||||
// We must check exponent > 0, because if this is the case, the number
|
||||
// has trailing zeros. However, we *cannot* output these trailing zeros,
|
||||
// because doing so would change the precision of the value, and would
|
||||
// change stored data if the string converted number is round tripped.
|
||||
|
||||
if (scientific_exponent >= 34 || scientific_exponent <= -7 || exponent > 0) {
|
||||
// Scientific format
|
||||
string.push(significand[index++]);
|
||||
significand_digits = significand_digits - 1;
|
||||
|
||||
if (significand_digits) {
|
||||
string.push('.');
|
||||
}
|
||||
|
||||
for (i = 0; i < significand_digits; i++) {
|
||||
string.push(significand[index++]);
|
||||
}
|
||||
|
||||
// Exponent
|
||||
string.push('E');
|
||||
if (scientific_exponent > 0) {
|
||||
string.push('+' + scientific_exponent);
|
||||
} else {
|
||||
string.push(scientific_exponent);
|
||||
}
|
||||
} else {
|
||||
// Regular format with no decimal place
|
||||
if (exponent >= 0) {
|
||||
for (i = 0; i < significand_digits; i++) {
|
||||
string.push(significand[index++]);
|
||||
}
|
||||
} else {
|
||||
var radix_position = significand_digits + exponent;
|
||||
|
||||
// non-zero digits before radix
|
||||
if (radix_position > 0) {
|
||||
for (i = 0; i < radix_position; i++) {
|
||||
string.push(significand[index++]);
|
||||
}
|
||||
} else {
|
||||
string.push('0');
|
||||
}
|
||||
|
||||
string.push('.');
|
||||
// add leading zeros after radix
|
||||
while (radix_position++ < 0) {
|
||||
string.push('0');
|
||||
}
|
||||
|
||||
for (i = 0; i < significand_digits - Math.max(radix_position - 1, 0); i++) {
|
||||
string.push(significand[index++]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return string.join('');
|
||||
};
|
||||
|
||||
Decimal128.prototype.toJSON = function() {
|
||||
return { $numberDecimal: this.toString() };
|
||||
};
|
||||
|
||||
module.exports = Decimal128;
|
||||
module.exports.Decimal128 = Decimal128;
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* A class representation of the BSON Double type.
|
||||
*
|
||||
* @class
|
||||
* @param {number} value the number we want to represent as a double.
|
||||
* @return {Double}
|
||||
*/
|
||||
function Double(value) {
|
||||
if (!(this instanceof Double)) return new Double(value);
|
||||
|
||||
this._bsontype = 'Double';
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Access the number value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} returns the wrapped double number.
|
||||
*/
|
||||
Double.prototype.valueOf = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Double.prototype.toJSON = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
module.exports = Double;
|
||||
module.exports.Double = Double;
|
||||
+124
@@ -0,0 +1,124 @@
|
||||
// Copyright (c) 2008, Fair Oaks Labs, Inc.
|
||||
// All rights reserved.
|
||||
//
|
||||
// Redistribution and use in source and binary forms, with or without
|
||||
// modification, are permitted provided that the following conditions are met:
|
||||
//
|
||||
// * Redistributions of source code must retain the above copyright notice,
|
||||
// this list of conditions and the following disclaimer.
|
||||
//
|
||||
// * Redistributions in binary form must reproduce the above copyright notice,
|
||||
// this list of conditions and the following disclaimer in the documentation
|
||||
// and/or other materials provided with the distribution.
|
||||
//
|
||||
// * Neither the name of Fair Oaks Labs, Inc. nor the names of its contributors
|
||||
// may be used to endorse or promote products derived from this software
|
||||
// without specific prior written permission.
|
||||
//
|
||||
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
||||
// AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
||||
// IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
||||
// ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
|
||||
// LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
|
||||
// CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
|
||||
// SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
|
||||
// INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
|
||||
// CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
|
||||
// ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
|
||||
// POSSIBILITY OF SUCH DAMAGE.
|
||||
//
|
||||
//
|
||||
// Modifications to writeIEEE754 to support negative zeroes made by Brian White
|
||||
|
||||
var readIEEE754 = function(buffer, offset, endian, mLen, nBytes) {
|
||||
var e,
|
||||
m,
|
||||
bBE = endian === 'big',
|
||||
eLen = nBytes * 8 - mLen - 1,
|
||||
eMax = (1 << eLen) - 1,
|
||||
eBias = eMax >> 1,
|
||||
nBits = -7,
|
||||
i = bBE ? 0 : nBytes - 1,
|
||||
d = bBE ? 1 : -1,
|
||||
s = buffer[offset + i];
|
||||
|
||||
i += d;
|
||||
|
||||
e = s & ((1 << -nBits) - 1);
|
||||
s >>= -nBits;
|
||||
nBits += eLen;
|
||||
for (; nBits > 0; e = e * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||||
|
||||
m = e & ((1 << -nBits) - 1);
|
||||
e >>= -nBits;
|
||||
nBits += mLen;
|
||||
for (; nBits > 0; m = m * 256 + buffer[offset + i], i += d, nBits -= 8);
|
||||
|
||||
if (e === 0) {
|
||||
e = 1 - eBias;
|
||||
} else if (e === eMax) {
|
||||
return m ? NaN : (s ? -1 : 1) * Infinity;
|
||||
} else {
|
||||
m = m + Math.pow(2, mLen);
|
||||
e = e - eBias;
|
||||
}
|
||||
return (s ? -1 : 1) * m * Math.pow(2, e - mLen);
|
||||
};
|
||||
|
||||
var writeIEEE754 = function(buffer, value, offset, endian, mLen, nBytes) {
|
||||
var e,
|
||||
m,
|
||||
c,
|
||||
bBE = endian === 'big',
|
||||
eLen = nBytes * 8 - mLen - 1,
|
||||
eMax = (1 << eLen) - 1,
|
||||
eBias = eMax >> 1,
|
||||
rt = mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0,
|
||||
i = bBE ? nBytes - 1 : 0,
|
||||
d = bBE ? -1 : 1,
|
||||
s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0;
|
||||
|
||||
value = Math.abs(value);
|
||||
|
||||
if (isNaN(value) || value === Infinity) {
|
||||
m = isNaN(value) ? 1 : 0;
|
||||
e = eMax;
|
||||
} else {
|
||||
e = Math.floor(Math.log(value) / Math.LN2);
|
||||
if (value * (c = Math.pow(2, -e)) < 1) {
|
||||
e--;
|
||||
c *= 2;
|
||||
}
|
||||
if (e + eBias >= 1) {
|
||||
value += rt / c;
|
||||
} else {
|
||||
value += rt * Math.pow(2, 1 - eBias);
|
||||
}
|
||||
if (value * c >= 2) {
|
||||
e++;
|
||||
c /= 2;
|
||||
}
|
||||
|
||||
if (e + eBias >= eMax) {
|
||||
m = 0;
|
||||
e = eMax;
|
||||
} else if (e + eBias >= 1) {
|
||||
m = (value * c - 1) * Math.pow(2, mLen);
|
||||
e = e + eBias;
|
||||
} else {
|
||||
m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen);
|
||||
e = 0;
|
||||
}
|
||||
}
|
||||
|
||||
for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8);
|
||||
|
||||
e = (e << mLen) | m;
|
||||
eLen += mLen;
|
||||
for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8);
|
||||
|
||||
buffer[offset + i - d] |= s * 128;
|
||||
};
|
||||
|
||||
exports.readIEEE754 = readIEEE754;
|
||||
exports.writeIEEE754 = writeIEEE754;
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* A class representation of a BSON Int32 type.
|
||||
*
|
||||
* @class
|
||||
* @param {number} value the number we want to represent as an int32.
|
||||
* @return {Int32}
|
||||
*/
|
||||
var Int32 = function(value) {
|
||||
if (!(this instanceof Int32)) return new Int32(value);
|
||||
|
||||
this._bsontype = 'Int32';
|
||||
this.value = value;
|
||||
};
|
||||
|
||||
/**
|
||||
* Access the number value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} returns the wrapped int32 number.
|
||||
*/
|
||||
Int32.prototype.valueOf = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Int32.prototype.toJSON = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
module.exports = Int32;
|
||||
module.exports.Int32 = Int32;
|
||||
+851
@@ -0,0 +1,851 @@
|
||||
// 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 2009 Google Inc. All Rights Reserved
|
||||
|
||||
/**
|
||||
* Defines a Long class for representing a 64-bit two's-complement
|
||||
* integer value, which faithfully simulates the behavior of a Java "Long". This
|
||||
* implementation is derived from LongLib in GWT.
|
||||
*
|
||||
* Constructs a 64-bit two's-complement integer, given its low and high 32-bit
|
||||
* values as *signed* integers. See the from* functions below for more
|
||||
* convenient ways of constructing Longs.
|
||||
*
|
||||
* The internal representation of a Long is the two given signed, 32-bit values.
|
||||
* We use 32-bit pieces because these are the size of integers on which
|
||||
* Javascript performs bit-operations. For operations like addition and
|
||||
* multiplication, we split each number into 16-bit pieces, which can easily be
|
||||
* multiplied within Javascript's floating-point representation without overflow
|
||||
* or change in sign.
|
||||
*
|
||||
* In the algorithms below, we frequently reduce the negative case to the
|
||||
* positive case by negating the input(s) and then post-processing the result.
|
||||
* Note that we must ALWAYS check specially whether those values are MIN_VALUE
|
||||
* (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
|
||||
* a positive number, it overflows back into a negative). Not handling this
|
||||
* case would often result in infinite recursion.
|
||||
*
|
||||
* @class
|
||||
* @param {number} low the low (signed) 32 bits of the Long.
|
||||
* @param {number} high the high (signed) 32 bits of the Long.
|
||||
* @return {Long}
|
||||
*/
|
||||
function Long(low, high) {
|
||||
if (!(this instanceof Long)) return new Long(low, high);
|
||||
|
||||
this._bsontype = 'Long';
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
this.low_ = low | 0; // force into 32 signed bits.
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
this.high_ = high | 0; // force into 32 signed bits.
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the int value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the value, assuming it is a 32-bit integer.
|
||||
*/
|
||||
Long.prototype.toInt = function() {
|
||||
return this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the Number value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the closest floating-point representation to this value.
|
||||
*/
|
||||
Long.prototype.toNumber = function() {
|
||||
return this.high_ * Long.TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the JSON value.
|
||||
*
|
||||
* @method
|
||||
* @return {string} the JSON representation.
|
||||
*/
|
||||
Long.prototype.toJSON = function() {
|
||||
return this.toString();
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the String value.
|
||||
*
|
||||
* @method
|
||||
* @param {number} [opt_radix] the radix in which the text should be written.
|
||||
* @return {string} the textual representation of this value.
|
||||
*/
|
||||
Long.prototype.toString = function(opt_radix) {
|
||||
var radix = opt_radix || 10;
|
||||
if (radix < 2 || 36 < radix) {
|
||||
throw Error('radix out of range: ' + radix);
|
||||
}
|
||||
|
||||
if (this.isZero()) {
|
||||
return '0';
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (this.equals(Long.MIN_VALUE)) {
|
||||
// We need to change the Long value before it can be negated, so we remove
|
||||
// the bottom-most digit in this base and then recurse to do the rest.
|
||||
var radixLong = Long.fromNumber(radix);
|
||||
var div = this.div(radixLong);
|
||||
var rem = div.multiply(radixLong).subtract(this);
|
||||
return div.toString(radix) + rem.toInt().toString(radix);
|
||||
} else {
|
||||
return '-' + this.negate().toString(radix);
|
||||
}
|
||||
}
|
||||
|
||||
// Do several (6) digits each time through the loop, so as to
|
||||
// minimize the calls to the very expensive emulated div.
|
||||
var radixToPower = Long.fromNumber(Math.pow(radix, 6));
|
||||
|
||||
rem = this;
|
||||
var result = '';
|
||||
|
||||
while (!rem.isZero()) {
|
||||
var remDiv = rem.div(radixToPower);
|
||||
var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
|
||||
var digits = intval.toString(radix);
|
||||
|
||||
rem = remDiv;
|
||||
if (rem.isZero()) {
|
||||
return digits + result;
|
||||
} else {
|
||||
while (digits.length < 6) {
|
||||
digits = '0' + digits;
|
||||
}
|
||||
result = '' + digits + result;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the high 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the high 32-bits as a signed value.
|
||||
*/
|
||||
Long.prototype.getHighBits = function() {
|
||||
return this.high_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the low 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the low 32-bits as a signed value.
|
||||
*/
|
||||
Long.prototype.getLowBits = function() {
|
||||
return this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the low unsigned 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the low 32-bits as an unsigned value.
|
||||
*/
|
||||
Long.prototype.getLowBitsUnsigned = function() {
|
||||
return this.low_ >= 0 ? this.low_ : Long.TWO_PWR_32_DBL_ + this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the number of bits needed to represent the absolute value of this Long.
|
||||
*
|
||||
* @method
|
||||
* @return {number} Returns the number of bits needed to represent the absolute value of this Long.
|
||||
*/
|
||||
Long.prototype.getNumBitsAbs = function() {
|
||||
if (this.isNegative()) {
|
||||
if (this.equals(Long.MIN_VALUE)) {
|
||||
return 64;
|
||||
} else {
|
||||
return this.negate().getNumBitsAbs();
|
||||
}
|
||||
} else {
|
||||
var val = this.high_ !== 0 ? this.high_ : this.low_;
|
||||
for (var bit = 31; bit > 0; bit--) {
|
||||
if ((val & (1 << bit)) !== 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return this.high_ !== 0 ? bit + 33 : bit + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is zero.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is zero.
|
||||
*/
|
||||
Long.prototype.isZero = function() {
|
||||
return this.high_ === 0 && this.low_ === 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is negative.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is negative.
|
||||
*/
|
||||
Long.prototype.isNegative = function() {
|
||||
return this.high_ < 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is odd.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is odd.
|
||||
*/
|
||||
Long.prototype.isOdd = function() {
|
||||
return (this.low_ & 1) === 1;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long equals the other
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long equals the other
|
||||
*/
|
||||
Long.prototype.equals = function(other) {
|
||||
return this.high_ === other.high_ && this.low_ === other.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long does not equal the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long does not equal the other.
|
||||
*/
|
||||
Long.prototype.notEquals = function(other) {
|
||||
return this.high_ !== other.high_ || this.low_ !== other.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long is less than the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long is less than the other.
|
||||
*/
|
||||
Long.prototype.lessThan = function(other) {
|
||||
return this.compare(other) < 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long is less than or equal to the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long is less than or equal to the other.
|
||||
*/
|
||||
Long.prototype.lessThanOrEqual = function(other) {
|
||||
return this.compare(other) <= 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long is greater than the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long is greater than the other.
|
||||
*/
|
||||
Long.prototype.greaterThan = function(other) {
|
||||
return this.compare(other) > 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Long is greater than or equal to the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} whether this Long is greater than or equal to the other.
|
||||
*/
|
||||
Long.prototype.greaterThanOrEqual = function(other) {
|
||||
return this.compare(other) >= 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Compares this Long with the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to compare against.
|
||||
* @return {boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.
|
||||
*/
|
||||
Long.prototype.compare = function(other) {
|
||||
if (this.equals(other)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
var thisNeg = this.isNegative();
|
||||
var otherNeg = other.isNegative();
|
||||
if (thisNeg && !otherNeg) {
|
||||
return -1;
|
||||
}
|
||||
if (!thisNeg && otherNeg) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// at this point, the signs are the same, so subtraction will not overflow
|
||||
if (this.subtract(other).isNegative()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The negation of this value.
|
||||
*
|
||||
* @method
|
||||
* @return {Long} the negation of this value.
|
||||
*/
|
||||
Long.prototype.negate = function() {
|
||||
if (this.equals(Long.MIN_VALUE)) {
|
||||
return Long.MIN_VALUE;
|
||||
} else {
|
||||
return this.not().add(Long.ONE);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the sum of this and the given Long.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to add to this one.
|
||||
* @return {Long} the sum of this and the given Long.
|
||||
*/
|
||||
Long.prototype.add = function(other) {
|
||||
// Divide each number into 4 chunks of 16 bits, and then sum the chunks.
|
||||
|
||||
var a48 = this.high_ >>> 16;
|
||||
var a32 = this.high_ & 0xffff;
|
||||
var a16 = this.low_ >>> 16;
|
||||
var a00 = this.low_ & 0xffff;
|
||||
|
||||
var b48 = other.high_ >>> 16;
|
||||
var b32 = other.high_ & 0xffff;
|
||||
var b16 = other.low_ >>> 16;
|
||||
var b00 = other.low_ & 0xffff;
|
||||
|
||||
var c48 = 0,
|
||||
c32 = 0,
|
||||
c16 = 0,
|
||||
c00 = 0;
|
||||
c00 += a00 + b00;
|
||||
c16 += c00 >>> 16;
|
||||
c00 &= 0xffff;
|
||||
c16 += a16 + b16;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c32 += a32 + b32;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c48 += a48 + b48;
|
||||
c48 &= 0xffff;
|
||||
return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the difference of this and the given Long.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to subtract from this.
|
||||
* @return {Long} the difference of this and the given Long.
|
||||
*/
|
||||
Long.prototype.subtract = function(other) {
|
||||
return this.add(other.negate());
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the product of this and the given Long.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long to multiply with this.
|
||||
* @return {Long} the product of this and the other.
|
||||
*/
|
||||
Long.prototype.multiply = function(other) {
|
||||
if (this.isZero()) {
|
||||
return Long.ZERO;
|
||||
} else if (other.isZero()) {
|
||||
return Long.ZERO;
|
||||
}
|
||||
|
||||
if (this.equals(Long.MIN_VALUE)) {
|
||||
return other.isOdd() ? Long.MIN_VALUE : Long.ZERO;
|
||||
} else if (other.equals(Long.MIN_VALUE)) {
|
||||
return this.isOdd() ? Long.MIN_VALUE : Long.ZERO;
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (other.isNegative()) {
|
||||
return this.negate().multiply(other.negate());
|
||||
} else {
|
||||
return this.negate()
|
||||
.multiply(other)
|
||||
.negate();
|
||||
}
|
||||
} else if (other.isNegative()) {
|
||||
return this.multiply(other.negate()).negate();
|
||||
}
|
||||
|
||||
// If both Longs are small, use float multiplication
|
||||
if (this.lessThan(Long.TWO_PWR_24_) && other.lessThan(Long.TWO_PWR_24_)) {
|
||||
return Long.fromNumber(this.toNumber() * other.toNumber());
|
||||
}
|
||||
|
||||
// Divide each Long into 4 chunks of 16 bits, and then add up 4x4 products.
|
||||
// We can skip products that would overflow.
|
||||
|
||||
var a48 = this.high_ >>> 16;
|
||||
var a32 = this.high_ & 0xffff;
|
||||
var a16 = this.low_ >>> 16;
|
||||
var a00 = this.low_ & 0xffff;
|
||||
|
||||
var b48 = other.high_ >>> 16;
|
||||
var b32 = other.high_ & 0xffff;
|
||||
var b16 = other.low_ >>> 16;
|
||||
var b00 = other.low_ & 0xffff;
|
||||
|
||||
var c48 = 0,
|
||||
c32 = 0,
|
||||
c16 = 0,
|
||||
c00 = 0;
|
||||
c00 += a00 * b00;
|
||||
c16 += c00 >>> 16;
|
||||
c00 &= 0xffff;
|
||||
c16 += a16 * b00;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c16 += a00 * b16;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c32 += a32 * b00;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c32 += a16 * b16;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c32 += a00 * b32;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
|
||||
c48 &= 0xffff;
|
||||
return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Long divided by the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long by which to divide.
|
||||
* @return {Long} this Long divided by the given one.
|
||||
*/
|
||||
Long.prototype.div = function(other) {
|
||||
if (other.isZero()) {
|
||||
throw Error('division by zero');
|
||||
} else if (this.isZero()) {
|
||||
return Long.ZERO;
|
||||
}
|
||||
|
||||
if (this.equals(Long.MIN_VALUE)) {
|
||||
if (other.equals(Long.ONE) || other.equals(Long.NEG_ONE)) {
|
||||
return Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
|
||||
} else if (other.equals(Long.MIN_VALUE)) {
|
||||
return Long.ONE;
|
||||
} else {
|
||||
// At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
|
||||
var halfThis = this.shiftRight(1);
|
||||
var approx = halfThis.div(other).shiftLeft(1);
|
||||
if (approx.equals(Long.ZERO)) {
|
||||
return other.isNegative() ? Long.ONE : Long.NEG_ONE;
|
||||
} else {
|
||||
var rem = this.subtract(other.multiply(approx));
|
||||
var result = approx.add(rem.div(other));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
} else if (other.equals(Long.MIN_VALUE)) {
|
||||
return Long.ZERO;
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (other.isNegative()) {
|
||||
return this.negate().div(other.negate());
|
||||
} else {
|
||||
return this.negate()
|
||||
.div(other)
|
||||
.negate();
|
||||
}
|
||||
} else if (other.isNegative()) {
|
||||
return this.div(other.negate()).negate();
|
||||
}
|
||||
|
||||
// Repeat the following until the remainder is less than other: find a
|
||||
// floating-point that approximates remainder / other *from below*, add this
|
||||
// into the result, and subtract it from the remainder. It is critical that
|
||||
// the approximate value is less than or equal to the real value so that the
|
||||
// remainder never becomes negative.
|
||||
var res = Long.ZERO;
|
||||
rem = this;
|
||||
while (rem.greaterThanOrEqual(other)) {
|
||||
// Approximate the result of division. This may be a little greater or
|
||||
// smaller than the actual value.
|
||||
approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
|
||||
|
||||
// We will tweak the approximate result by changing it in the 48-th digit or
|
||||
// the smallest non-fractional digit, whichever is larger.
|
||||
var log2 = Math.ceil(Math.log(approx) / Math.LN2);
|
||||
var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
|
||||
|
||||
// Decrease the approximation until it is smaller than the remainder. Note
|
||||
// that if it is too large, the product overflows and is negative.
|
||||
var approxRes = Long.fromNumber(approx);
|
||||
var approxRem = approxRes.multiply(other);
|
||||
while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
|
||||
approx -= delta;
|
||||
approxRes = Long.fromNumber(approx);
|
||||
approxRem = approxRes.multiply(other);
|
||||
}
|
||||
|
||||
// We know the answer can't be zero... and actually, zero would cause
|
||||
// infinite recursion since we would make no progress.
|
||||
if (approxRes.isZero()) {
|
||||
approxRes = Long.ONE;
|
||||
}
|
||||
|
||||
res = res.add(approxRes);
|
||||
rem = rem.subtract(approxRem);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Long modulo the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other Long by which to mod.
|
||||
* @return {Long} this Long modulo the given one.
|
||||
*/
|
||||
Long.prototype.modulo = function(other) {
|
||||
return this.subtract(this.div(other).multiply(other));
|
||||
};
|
||||
|
||||
/**
|
||||
* The bitwise-NOT of this value.
|
||||
*
|
||||
* @method
|
||||
* @return {Long} the bitwise-NOT of this value.
|
||||
*/
|
||||
Long.prototype.not = function() {
|
||||
return Long.fromBits(~this.low_, ~this.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-AND of this Long and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other the Long with which to AND.
|
||||
* @return {Long} the bitwise-AND of this and the other.
|
||||
*/
|
||||
Long.prototype.and = function(other) {
|
||||
return Long.fromBits(this.low_ & other.low_, this.high_ & other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-OR of this Long and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other the Long with which to OR.
|
||||
* @return {Long} the bitwise-OR of this and the other.
|
||||
*/
|
||||
Long.prototype.or = function(other) {
|
||||
return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-XOR of this Long and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Long} other the Long with which to XOR.
|
||||
* @return {Long} the bitwise-XOR of this and the other.
|
||||
*/
|
||||
Long.prototype.xor = function(other) {
|
||||
return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Long with bits shifted to the left by the given amount.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Long} this shifted to the left by the given amount.
|
||||
*/
|
||||
Long.prototype.shiftLeft = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var low = this.low_;
|
||||
if (numBits < 32) {
|
||||
var high = this.high_;
|
||||
return Long.fromBits(low << numBits, (high << numBits) | (low >>> (32 - numBits)));
|
||||
} else {
|
||||
return Long.fromBits(0, low << (numBits - 32));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Long with bits shifted to the right by the given amount.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Long} this shifted to the right by the given amount.
|
||||
*/
|
||||
Long.prototype.shiftRight = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var high = this.high_;
|
||||
if (numBits < 32) {
|
||||
var low = this.low_;
|
||||
return Long.fromBits((low >>> numBits) | (high << (32 - numBits)), high >> numBits);
|
||||
} else {
|
||||
return Long.fromBits(high >> (numBits - 32), high >= 0 ? 0 : -1);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Long with bits shifted to the right by the given amount, with the new top bits matching the current sign bit.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Long} this shifted to the right by the given amount, with zeros placed into the new leading bits.
|
||||
*/
|
||||
Long.prototype.shiftRightUnsigned = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var high = this.high_;
|
||||
if (numBits < 32) {
|
||||
var low = this.low_;
|
||||
return Long.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits);
|
||||
} else if (numBits === 32) {
|
||||
return Long.fromBits(high, 0);
|
||||
} else {
|
||||
return Long.fromBits(high >>> (numBits - 32), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Long representing the given (32-bit) integer value.
|
||||
*
|
||||
* @method
|
||||
* @param {number} value the 32-bit integer in question.
|
||||
* @return {Long} the corresponding Long value.
|
||||
*/
|
||||
Long.fromInt = function(value) {
|
||||
if (-128 <= value && value < 128) {
|
||||
var cachedObj = Long.INT_CACHE_[value];
|
||||
if (cachedObj) {
|
||||
return cachedObj;
|
||||
}
|
||||
}
|
||||
|
||||
var obj = new Long(value | 0, value < 0 ? -1 : 0);
|
||||
if (-128 <= value && value < 128) {
|
||||
Long.INT_CACHE_[value] = obj;
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
|
||||
*
|
||||
* @method
|
||||
* @param {number} value the number in question.
|
||||
* @return {Long} the corresponding Long value.
|
||||
*/
|
||||
Long.fromNumber = function(value) {
|
||||
if (isNaN(value) || !isFinite(value)) {
|
||||
return Long.ZERO;
|
||||
} else if (value <= -Long.TWO_PWR_63_DBL_) {
|
||||
return Long.MIN_VALUE;
|
||||
} else if (value + 1 >= Long.TWO_PWR_63_DBL_) {
|
||||
return Long.MAX_VALUE;
|
||||
} else if (value < 0) {
|
||||
return Long.fromNumber(-value).negate();
|
||||
} else {
|
||||
return new Long((value % Long.TWO_PWR_32_DBL_) | 0, (value / Long.TWO_PWR_32_DBL_) | 0);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Long representing the 64-bit integer that comes by concatenating the given high and low bits. Each is assumed to use 32 bits.
|
||||
*
|
||||
* @method
|
||||
* @param {number} lowBits the low 32-bits.
|
||||
* @param {number} highBits the high 32-bits.
|
||||
* @return {Long} the corresponding Long value.
|
||||
*/
|
||||
Long.fromBits = function(lowBits, highBits) {
|
||||
return new Long(lowBits, highBits);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Long representation of the given string, written using the given radix.
|
||||
*
|
||||
* @method
|
||||
* @param {string} str the textual representation of the Long.
|
||||
* @param {number} opt_radix the radix in which the text is written.
|
||||
* @return {Long} the corresponding Long value.
|
||||
*/
|
||||
Long.fromString = function(str, opt_radix) {
|
||||
if (str.length === 0) {
|
||||
throw Error('number format error: empty string');
|
||||
}
|
||||
|
||||
var radix = opt_radix || 10;
|
||||
if (radix < 2 || 36 < radix) {
|
||||
throw Error('radix out of range: ' + radix);
|
||||
}
|
||||
|
||||
if (str.charAt(0) === '-') {
|
||||
return Long.fromString(str.substring(1), radix).negate();
|
||||
} else if (str.indexOf('-') >= 0) {
|
||||
throw Error('number format error: interior "-" character: ' + str);
|
||||
}
|
||||
|
||||
// Do several (8) digits each time through the loop, so as to
|
||||
// minimize the calls to the very expensive emulated div.
|
||||
var radixToPower = Long.fromNumber(Math.pow(radix, 8));
|
||||
|
||||
var result = Long.ZERO;
|
||||
for (var i = 0; i < str.length; i += 8) {
|
||||
var size = Math.min(8, str.length - i);
|
||||
var value = parseInt(str.substring(i, i + size), radix);
|
||||
if (size < 8) {
|
||||
var power = Long.fromNumber(Math.pow(radix, size));
|
||||
result = result.multiply(power).add(Long.fromNumber(value));
|
||||
} else {
|
||||
result = result.multiply(radixToPower);
|
||||
result = result.add(Long.fromNumber(value));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
|
||||
// from* methods on which they depend.
|
||||
|
||||
/**
|
||||
* A cache of the Long representations of small integer values.
|
||||
* @type {Object}
|
||||
* @ignore
|
||||
*/
|
||||
Long.INT_CACHE_ = {};
|
||||
|
||||
// NOTE: the compiler should inline these constant values below and then remove
|
||||
// these variables, so there should be no runtime penalty for these.
|
||||
|
||||
/**
|
||||
* Number used repeated below in calculations. This must appear before the
|
||||
* first call to any from* function below.
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_16_DBL_ = 1 << 16;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_24_DBL_ = 1 << 24;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_32_DBL_ = Long.TWO_PWR_16_DBL_ * Long.TWO_PWR_16_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_31_DBL_ = Long.TWO_PWR_32_DBL_ / 2;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_48_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_16_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_64_DBL_ = Long.TWO_PWR_32_DBL_ * Long.TWO_PWR_32_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_63_DBL_ = Long.TWO_PWR_64_DBL_ / 2;
|
||||
|
||||
/** @type {Long} */
|
||||
Long.ZERO = Long.fromInt(0);
|
||||
|
||||
/** @type {Long} */
|
||||
Long.ONE = Long.fromInt(1);
|
||||
|
||||
/** @type {Long} */
|
||||
Long.NEG_ONE = Long.fromInt(-1);
|
||||
|
||||
/** @type {Long} */
|
||||
Long.MAX_VALUE = Long.fromBits(0xffffffff | 0, 0x7fffffff | 0);
|
||||
|
||||
/** @type {Long} */
|
||||
Long.MIN_VALUE = Long.fromBits(0, 0x80000000 | 0);
|
||||
|
||||
/**
|
||||
* @type {Long}
|
||||
* @ignore
|
||||
*/
|
||||
Long.TWO_PWR_24_ = Long.fromInt(1 << 24);
|
||||
|
||||
/**
|
||||
* Expose.
|
||||
*/
|
||||
module.exports = Long;
|
||||
module.exports.Long = Long;
|
||||
+128
@@ -0,0 +1,128 @@
|
||||
'use strict';
|
||||
|
||||
// We have an ES6 Map available, return the native instance
|
||||
if (typeof global.Map !== 'undefined') {
|
||||
module.exports = global.Map;
|
||||
module.exports.Map = global.Map;
|
||||
} else {
|
||||
// We will return a polyfill
|
||||
var Map = function(array) {
|
||||
this._keys = [];
|
||||
this._values = {};
|
||||
|
||||
for (var i = 0; i < array.length; i++) {
|
||||
if (array[i] == null) continue; // skip null and undefined
|
||||
var entry = array[i];
|
||||
var key = entry[0];
|
||||
var value = entry[1];
|
||||
// Add the key to the list of keys in order
|
||||
this._keys.push(key);
|
||||
// Add the key and value to the values dictionary with a point
|
||||
// to the location in the ordered keys list
|
||||
this._values[key] = { v: value, i: this._keys.length - 1 };
|
||||
}
|
||||
};
|
||||
|
||||
Map.prototype.clear = function() {
|
||||
this._keys = [];
|
||||
this._values = {};
|
||||
};
|
||||
|
||||
Map.prototype.delete = function(key) {
|
||||
var value = this._values[key];
|
||||
if (value == null) return false;
|
||||
// Delete entry
|
||||
delete this._values[key];
|
||||
// Remove the key from the ordered keys list
|
||||
this._keys.splice(value.i, 1);
|
||||
return true;
|
||||
};
|
||||
|
||||
Map.prototype.entries = function() {
|
||||
var self = this;
|
||||
var index = 0;
|
||||
|
||||
return {
|
||||
next: function() {
|
||||
var key = self._keys[index++];
|
||||
return {
|
||||
value: key !== undefined ? [key, self._values[key].v] : undefined,
|
||||
done: key !== undefined ? false : true
|
||||
};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
Map.prototype.forEach = function(callback, self) {
|
||||
self = self || this;
|
||||
|
||||
for (var i = 0; i < this._keys.length; i++) {
|
||||
var key = this._keys[i];
|
||||
// Call the forEach callback
|
||||
callback.call(self, this._values[key].v, key, self);
|
||||
}
|
||||
};
|
||||
|
||||
Map.prototype.get = function(key) {
|
||||
return this._values[key] ? this._values[key].v : undefined;
|
||||
};
|
||||
|
||||
Map.prototype.has = function(key) {
|
||||
return this._values[key] != null;
|
||||
};
|
||||
|
||||
Map.prototype.keys = function() {
|
||||
var self = this;
|
||||
var index = 0;
|
||||
|
||||
return {
|
||||
next: function() {
|
||||
var key = self._keys[index++];
|
||||
return {
|
||||
value: key !== undefined ? key : undefined,
|
||||
done: key !== undefined ? false : true
|
||||
};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
Map.prototype.set = function(key, value) {
|
||||
if (this._values[key]) {
|
||||
this._values[key].v = value;
|
||||
return this;
|
||||
}
|
||||
|
||||
// Add the key to the list of keys in order
|
||||
this._keys.push(key);
|
||||
// Add the key and value to the values dictionary with a point
|
||||
// to the location in the ordered keys list
|
||||
this._values[key] = { v: value, i: this._keys.length - 1 };
|
||||
return this;
|
||||
};
|
||||
|
||||
Map.prototype.values = function() {
|
||||
var self = this;
|
||||
var index = 0;
|
||||
|
||||
return {
|
||||
next: function() {
|
||||
var key = self._keys[index++];
|
||||
return {
|
||||
value: key !== undefined ? self._values[key].v : undefined,
|
||||
done: key !== undefined ? false : true
|
||||
};
|
||||
}
|
||||
};
|
||||
};
|
||||
|
||||
// Last ismaster
|
||||
Object.defineProperty(Map.prototype, 'size', {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return this._keys.length;
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = Map;
|
||||
module.exports.Map = Map;
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/**
|
||||
* A class representation of the BSON MaxKey type.
|
||||
*
|
||||
* @class
|
||||
* @return {MaxKey} A MaxKey instance
|
||||
*/
|
||||
function MaxKey() {
|
||||
if (!(this instanceof MaxKey)) return new MaxKey();
|
||||
|
||||
this._bsontype = 'MaxKey';
|
||||
}
|
||||
|
||||
module.exports = MaxKey;
|
||||
module.exports.MaxKey = MaxKey;
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
/**
|
||||
* A class representation of the BSON MinKey type.
|
||||
*
|
||||
* @class
|
||||
* @return {MinKey} A MinKey instance
|
||||
*/
|
||||
function MinKey() {
|
||||
if (!(this instanceof MinKey)) return new MinKey();
|
||||
|
||||
this._bsontype = 'MinKey';
|
||||
}
|
||||
|
||||
module.exports = MinKey;
|
||||
module.exports.MinKey = MinKey;
|
||||
+387
@@ -0,0 +1,387 @@
|
||||
// Custom inspect property name / symbol.
|
||||
var inspect = 'inspect';
|
||||
|
||||
/**
|
||||
* Machine id.
|
||||
*
|
||||
* Create a random 3-byte value (i.e. unique for this
|
||||
* process). Other drivers use a md5 of the machine id here, but
|
||||
* that would mean an asyc call to gethostname, so we don't bother.
|
||||
* @ignore
|
||||
*/
|
||||
var MACHINE_ID = parseInt(Math.random() * 0xffffff, 10);
|
||||
|
||||
// Regular expression that checks for hex value
|
||||
var checkForHexRegExp = new RegExp('^[0-9a-fA-F]{24}$');
|
||||
|
||||
// Check if buffer exists
|
||||
try {
|
||||
if (Buffer && Buffer.from) {
|
||||
var hasBufferType = true;
|
||||
inspect = require('util').inspect.custom || 'inspect';
|
||||
}
|
||||
} catch (err) {
|
||||
hasBufferType = false;
|
||||
}
|
||||
|
||||
/**
|
||||
* Create a new ObjectID instance
|
||||
*
|
||||
* @class
|
||||
* @param {(string|number)} id Can be a 24 byte hex string, 12 byte binary string or a Number.
|
||||
* @property {number} generationTime The generation time of this ObjectId instance
|
||||
* @return {ObjectID} instance of ObjectID.
|
||||
*/
|
||||
var ObjectID = function ObjectID(id) {
|
||||
// Duck-typing to support ObjectId from different npm packages
|
||||
if (id instanceof ObjectID) return id;
|
||||
if (!(this instanceof ObjectID)) return new ObjectID(id);
|
||||
|
||||
this._bsontype = 'ObjectID';
|
||||
|
||||
// The most common usecase (blank id, new objectId instance)
|
||||
if (id == null || typeof id === 'number') {
|
||||
// Generate a new id
|
||||
this.id = this.generate(id);
|
||||
// If we are caching the hex string
|
||||
if (ObjectID.cacheHexString) this.__id = this.toString('hex');
|
||||
// Return the object
|
||||
return;
|
||||
}
|
||||
|
||||
// Check if the passed in id is valid
|
||||
var valid = ObjectID.isValid(id);
|
||||
|
||||
// Throw an error if it's not a valid setup
|
||||
if (!valid && id != null) {
|
||||
throw new Error(
|
||||
'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'
|
||||
);
|
||||
} else if (valid && typeof id === 'string' && id.length === 24 && hasBufferType) {
|
||||
return new ObjectID(new Buffer(id, 'hex'));
|
||||
} else if (valid && typeof id === 'string' && id.length === 24) {
|
||||
return ObjectID.createFromHexString(id);
|
||||
} else if (id != null && id.length === 12) {
|
||||
// assume 12 byte string
|
||||
this.id = id;
|
||||
} else if (id != null && id.toHexString) {
|
||||
// Duck-typing to support ObjectId from different npm packages
|
||||
return id;
|
||||
} else {
|
||||
throw new Error(
|
||||
'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'
|
||||
);
|
||||
}
|
||||
|
||||
if (ObjectID.cacheHexString) this.__id = this.toString('hex');
|
||||
};
|
||||
|
||||
// Allow usage of ObjectId as well as ObjectID
|
||||
// var ObjectId = ObjectID;
|
||||
|
||||
// Precomputed hex table enables speedy hex string conversion
|
||||
var hexTable = [];
|
||||
for (var i = 0; i < 256; i++) {
|
||||
hexTable[i] = (i <= 15 ? '0' : '') + i.toString(16);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the ObjectID id as a 24 byte hex string representation
|
||||
*
|
||||
* @method
|
||||
* @return {string} return the 24 byte hex string representation.
|
||||
*/
|
||||
ObjectID.prototype.toHexString = function() {
|
||||
if (ObjectID.cacheHexString && this.__id) return this.__id;
|
||||
|
||||
var hexString = '';
|
||||
if (!this.id || !this.id.length) {
|
||||
throw new Error(
|
||||
'invalid ObjectId, ObjectId.id must be either a string or a Buffer, but is [' +
|
||||
JSON.stringify(this.id) +
|
||||
']'
|
||||
);
|
||||
}
|
||||
|
||||
if (this.id instanceof _Buffer) {
|
||||
hexString = convertToHex(this.id);
|
||||
if (ObjectID.cacheHexString) this.__id = hexString;
|
||||
return hexString;
|
||||
}
|
||||
|
||||
for (var i = 0; i < this.id.length; i++) {
|
||||
hexString += hexTable[this.id.charCodeAt(i)];
|
||||
}
|
||||
|
||||
if (ObjectID.cacheHexString) this.__id = hexString;
|
||||
return hexString;
|
||||
};
|
||||
|
||||
/**
|
||||
* Update the ObjectID index used in generating new ObjectID's on the driver
|
||||
*
|
||||
* @method
|
||||
* @return {number} returns next index value.
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.prototype.get_inc = function() {
|
||||
return (ObjectID.index = (ObjectID.index + 1) % 0xffffff);
|
||||
};
|
||||
|
||||
/**
|
||||
* Update the ObjectID index used in generating new ObjectID's on the driver
|
||||
*
|
||||
* @method
|
||||
* @return {number} returns next index value.
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.prototype.getInc = function() {
|
||||
return this.get_inc();
|
||||
};
|
||||
|
||||
/**
|
||||
* Generate a 12 byte id buffer used in ObjectID's
|
||||
*
|
||||
* @method
|
||||
* @param {number} [time] optional parameter allowing to pass in a second based timestamp.
|
||||
* @return {Buffer} return the 12 byte id buffer string.
|
||||
*/
|
||||
ObjectID.prototype.generate = function(time) {
|
||||
if ('number' !== typeof time) {
|
||||
time = ~~(Date.now() / 1000);
|
||||
}
|
||||
|
||||
// Use pid
|
||||
var pid =
|
||||
(typeof process === 'undefined' || process.pid === 1
|
||||
? Math.floor(Math.random() * 100000)
|
||||
: process.pid) % 0xffff;
|
||||
var inc = this.get_inc();
|
||||
// Buffer used
|
||||
var buffer = new Buffer(12);
|
||||
// Encode time
|
||||
buffer[3] = time & 0xff;
|
||||
buffer[2] = (time >> 8) & 0xff;
|
||||
buffer[1] = (time >> 16) & 0xff;
|
||||
buffer[0] = (time >> 24) & 0xff;
|
||||
// Encode machine
|
||||
buffer[6] = MACHINE_ID & 0xff;
|
||||
buffer[5] = (MACHINE_ID >> 8) & 0xff;
|
||||
buffer[4] = (MACHINE_ID >> 16) & 0xff;
|
||||
// Encode pid
|
||||
buffer[8] = pid & 0xff;
|
||||
buffer[7] = (pid >> 8) & 0xff;
|
||||
// Encode index
|
||||
buffer[11] = inc & 0xff;
|
||||
buffer[10] = (inc >> 8) & 0xff;
|
||||
buffer[9] = (inc >> 16) & 0xff;
|
||||
// Return the buffer
|
||||
return buffer;
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts the id into a 24 byte hex string for printing
|
||||
*
|
||||
* @param {String} format The Buffer toString format parameter.
|
||||
* @return {String} return the 24 byte hex string representation.
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.prototype.toString = function(format) {
|
||||
// Is the id a buffer then use the buffer toString method to return the format
|
||||
if (this.id && this.id.copy) {
|
||||
return this.id.toString(typeof format === 'string' ? format : 'hex');
|
||||
}
|
||||
|
||||
// if(this.buffer )
|
||||
return this.toHexString();
|
||||
};
|
||||
|
||||
/**
|
||||
* Converts to a string representation of this Id.
|
||||
*
|
||||
* @return {String} return the 24 byte hex string representation.
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.prototype[inspect] = ObjectID.prototype.toString;
|
||||
|
||||
/**
|
||||
* Converts to its JSON representation.
|
||||
*
|
||||
* @return {String} return the 24 byte hex string representation.
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.prototype.toJSON = function() {
|
||||
return this.toHexString();
|
||||
};
|
||||
|
||||
/**
|
||||
* Compares the equality of this ObjectID with `otherID`.
|
||||
*
|
||||
* @method
|
||||
* @param {object} otherID ObjectID instance to compare against.
|
||||
* @return {boolean} the result of comparing two ObjectID's
|
||||
*/
|
||||
ObjectID.prototype.equals = function equals(otherId) {
|
||||
// var id;
|
||||
|
||||
if (otherId instanceof ObjectID) {
|
||||
return this.toString() === otherId.toString();
|
||||
} else if (
|
||||
typeof otherId === 'string' &&
|
||||
ObjectID.isValid(otherId) &&
|
||||
otherId.length === 12 &&
|
||||
this.id instanceof _Buffer
|
||||
) {
|
||||
return otherId === this.id.toString('binary');
|
||||
} else if (typeof otherId === 'string' && ObjectID.isValid(otherId) && otherId.length === 24) {
|
||||
return otherId.toLowerCase() === this.toHexString();
|
||||
} else if (typeof otherId === 'string' && ObjectID.isValid(otherId) && otherId.length === 12) {
|
||||
return otherId === this.id;
|
||||
} else if (otherId != null && (otherId instanceof ObjectID || otherId.toHexString)) {
|
||||
return otherId.toHexString() === this.toHexString();
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the generation date (accurate up to the second) that this ID was generated.
|
||||
*
|
||||
* @method
|
||||
* @return {date} the generation date
|
||||
*/
|
||||
ObjectID.prototype.getTimestamp = function() {
|
||||
var timestamp = new Date();
|
||||
var time = this.id[3] | (this.id[2] << 8) | (this.id[1] << 16) | (this.id[0] << 24);
|
||||
timestamp.setTime(Math.floor(time) * 1000);
|
||||
return timestamp;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.index = ~~(Math.random() * 0xffffff);
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
ObjectID.createPk = function createPk() {
|
||||
return new ObjectID();
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates an ObjectID from a second based number, with the rest of the ObjectID zeroed out. Used for comparisons or sorting the ObjectID.
|
||||
*
|
||||
* @method
|
||||
* @param {number} time an integer number representing a number of seconds.
|
||||
* @return {ObjectID} return the created ObjectID
|
||||
*/
|
||||
ObjectID.createFromTime = function createFromTime(time) {
|
||||
var buffer = new Buffer([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
|
||||
// Encode time into first 4 bytes
|
||||
buffer[3] = time & 0xff;
|
||||
buffer[2] = (time >> 8) & 0xff;
|
||||
buffer[1] = (time >> 16) & 0xff;
|
||||
buffer[0] = (time >> 24) & 0xff;
|
||||
// Return the new objectId
|
||||
return new ObjectID(buffer);
|
||||
};
|
||||
|
||||
// Lookup tables
|
||||
//var encodeLookup = '0123456789abcdef'.split('');
|
||||
var decodeLookup = [];
|
||||
i = 0;
|
||||
while (i < 10) decodeLookup[0x30 + i] = i++;
|
||||
while (i < 16) decodeLookup[0x41 - 10 + i] = decodeLookup[0x61 - 10 + i] = i++;
|
||||
|
||||
var _Buffer = Buffer;
|
||||
var convertToHex = function(bytes) {
|
||||
return bytes.toString('hex');
|
||||
};
|
||||
|
||||
/**
|
||||
* Creates an ObjectID from a hex string representation of an ObjectID.
|
||||
*
|
||||
* @method
|
||||
* @param {string} hexString create a ObjectID from a passed in 24 byte hexstring.
|
||||
* @return {ObjectID} return the created ObjectID
|
||||
*/
|
||||
ObjectID.createFromHexString = function createFromHexString(string) {
|
||||
// Throw an error if it's not a valid setup
|
||||
if (typeof string === 'undefined' || (string != null && string.length !== 24)) {
|
||||
throw new Error(
|
||||
'Argument passed in must be a single String of 12 bytes or a string of 24 hex characters'
|
||||
);
|
||||
}
|
||||
|
||||
// Use Buffer.from method if available
|
||||
if (hasBufferType) return new ObjectID(new Buffer(string, 'hex'));
|
||||
|
||||
// Calculate lengths
|
||||
var array = new _Buffer(12);
|
||||
var n = 0;
|
||||
var i = 0;
|
||||
|
||||
while (i < 24) {
|
||||
array[n++] = (decodeLookup[string.charCodeAt(i++)] << 4) | decodeLookup[string.charCodeAt(i++)];
|
||||
}
|
||||
|
||||
return new ObjectID(array);
|
||||
};
|
||||
|
||||
/**
|
||||
* Checks if a value is a valid bson ObjectId
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} return true if the value is a valid bson ObjectId, return false otherwise.
|
||||
*/
|
||||
ObjectID.isValid = function isValid(id) {
|
||||
if (id == null) return false;
|
||||
|
||||
if (typeof id === 'number') {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (typeof id === 'string') {
|
||||
return id.length === 12 || (id.length === 24 && checkForHexRegExp.test(id));
|
||||
}
|
||||
|
||||
if (id instanceof ObjectID) {
|
||||
return true;
|
||||
}
|
||||
|
||||
if (id instanceof _Buffer) {
|
||||
return true;
|
||||
}
|
||||
|
||||
// Duck-Typing detection of ObjectId like objects
|
||||
if (id.toHexString) {
|
||||
return id.id.length === 12 || (id.id.length === 24 && checkForHexRegExp.test(id.id));
|
||||
}
|
||||
|
||||
return false;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Object.defineProperty(ObjectID.prototype, 'generationTime', {
|
||||
enumerable: true,
|
||||
get: function() {
|
||||
return this.id[3] | (this.id[2] << 8) | (this.id[1] << 16) | (this.id[0] << 24);
|
||||
},
|
||||
set: function(value) {
|
||||
// Encode time into first 4 bytes
|
||||
this.id[3] = value & 0xff;
|
||||
this.id[2] = (value >> 8) & 0xff;
|
||||
this.id[1] = (value >> 16) & 0xff;
|
||||
this.id[0] = (value >> 24) & 0xff;
|
||||
}
|
||||
});
|
||||
|
||||
/**
|
||||
* Expose.
|
||||
*/
|
||||
module.exports = ObjectID;
|
||||
module.exports.ObjectID = ObjectID;
|
||||
module.exports.ObjectId = ObjectID;
|
||||
Generated
Vendored
+255
@@ -0,0 +1,255 @@
|
||||
'use strict';
|
||||
|
||||
var Long = require('../long').Long,
|
||||
Double = require('../double').Double,
|
||||
Timestamp = require('../timestamp').Timestamp,
|
||||
ObjectID = require('../objectid').ObjectID,
|
||||
Symbol = require('../symbol').Symbol,
|
||||
BSONRegExp = require('../regexp').BSONRegExp,
|
||||
Code = require('../code').Code,
|
||||
Decimal128 = require('../decimal128'),
|
||||
MinKey = require('../min_key').MinKey,
|
||||
MaxKey = require('../max_key').MaxKey,
|
||||
DBRef = require('../db_ref').DBRef,
|
||||
Binary = require('../binary').Binary;
|
||||
|
||||
var normalizedFunctionString = require('./utils').normalizedFunctionString;
|
||||
|
||||
// To ensure that 0.4 of node works correctly
|
||||
var isDate = function isDate(d) {
|
||||
return typeof d === 'object' && Object.prototype.toString.call(d) === '[object Date]';
|
||||
};
|
||||
|
||||
var calculateObjectSize = function calculateObjectSize(
|
||||
object,
|
||||
serializeFunctions,
|
||||
ignoreUndefined
|
||||
) {
|
||||
var totalLength = 4 + 1;
|
||||
|
||||
if (Array.isArray(object)) {
|
||||
for (var i = 0; i < object.length; i++) {
|
||||
totalLength += calculateElement(
|
||||
i.toString(),
|
||||
object[i],
|
||||
serializeFunctions,
|
||||
true,
|
||||
ignoreUndefined
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// If we have toBSON defined, override the current object
|
||||
if (object.toBSON) {
|
||||
object = object.toBSON();
|
||||
}
|
||||
|
||||
// Calculate size
|
||||
for (var key in object) {
|
||||
totalLength += calculateElement(key, object[key], serializeFunctions, false, ignoreUndefined);
|
||||
}
|
||||
}
|
||||
|
||||
return totalLength;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
function calculateElement(name, value, serializeFunctions, isArray, ignoreUndefined) {
|
||||
// If we have toBSON defined, override the current object
|
||||
if (value && value.toBSON) {
|
||||
value = value.toBSON();
|
||||
}
|
||||
|
||||
switch (typeof value) {
|
||||
case 'string':
|
||||
return 1 + Buffer.byteLength(name, 'utf8') + 1 + 4 + Buffer.byteLength(value, 'utf8') + 1;
|
||||
case 'number':
|
||||
if (Math.floor(value) === value && value >= BSON.JS_INT_MIN && value <= BSON.JS_INT_MAX) {
|
||||
if (value >= BSON.BSON_INT32_MIN && value <= BSON.BSON_INT32_MAX) {
|
||||
// 32 bit
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (4 + 1);
|
||||
} else {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);
|
||||
}
|
||||
} else {
|
||||
// 64 bit
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);
|
||||
}
|
||||
case 'undefined':
|
||||
if (isArray || !ignoreUndefined)
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + 1;
|
||||
return 0;
|
||||
case 'boolean':
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (1 + 1);
|
||||
case 'object':
|
||||
if (
|
||||
value == null ||
|
||||
value instanceof MinKey ||
|
||||
value instanceof MaxKey ||
|
||||
value['_bsontype'] === 'MinKey' ||
|
||||
value['_bsontype'] === 'MaxKey'
|
||||
) {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + 1;
|
||||
} else if (value instanceof ObjectID || value['_bsontype'] === 'ObjectID') {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (12 + 1);
|
||||
} else if (value instanceof Date || isDate(value)) {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);
|
||||
} else if (typeof Buffer !== 'undefined' && Buffer.isBuffer(value)) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (1 + 4 + 1) + value.length
|
||||
);
|
||||
} else if (
|
||||
value instanceof Long ||
|
||||
value instanceof Double ||
|
||||
value instanceof Timestamp ||
|
||||
value['_bsontype'] === 'Long' ||
|
||||
value['_bsontype'] === 'Double' ||
|
||||
value['_bsontype'] === 'Timestamp'
|
||||
) {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (8 + 1);
|
||||
} else if (value instanceof Decimal128 || value['_bsontype'] === 'Decimal128') {
|
||||
return (name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (16 + 1);
|
||||
} else if (value instanceof Code || value['_bsontype'] === 'Code') {
|
||||
// Calculate size depending on the availability of a scope
|
||||
if (value.scope != null && Object.keys(value.scope).length > 0) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
4 +
|
||||
4 +
|
||||
Buffer.byteLength(value.code.toString(), 'utf8') +
|
||||
1 +
|
||||
calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined)
|
||||
);
|
||||
} else {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
4 +
|
||||
Buffer.byteLength(value.code.toString(), 'utf8') +
|
||||
1
|
||||
);
|
||||
}
|
||||
} else if (value instanceof Binary || value['_bsontype'] === 'Binary') {
|
||||
// Check what kind of subtype we have
|
||||
if (value.sub_type === Binary.SUBTYPE_BYTE_ARRAY) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
(value.position + 1 + 4 + 1 + 4)
|
||||
);
|
||||
} else {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) + (value.position + 1 + 4 + 1)
|
||||
);
|
||||
}
|
||||
} else if (value instanceof Symbol || value['_bsontype'] === 'Symbol') {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
Buffer.byteLength(value.value, 'utf8') +
|
||||
4 +
|
||||
1 +
|
||||
1
|
||||
);
|
||||
} else if (value instanceof DBRef || value['_bsontype'] === 'DBRef') {
|
||||
// Set up correct object for serialization
|
||||
var ordered_values = {
|
||||
$ref: value.namespace,
|
||||
$id: value.oid
|
||||
};
|
||||
|
||||
// Add db reference if it exists
|
||||
if (null != value.db) {
|
||||
ordered_values['$db'] = value.db;
|
||||
}
|
||||
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
calculateObjectSize(ordered_values, serializeFunctions, ignoreUndefined)
|
||||
);
|
||||
} else if (
|
||||
value instanceof RegExp ||
|
||||
Object.prototype.toString.call(value) === '[object RegExp]'
|
||||
) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
Buffer.byteLength(value.source, 'utf8') +
|
||||
1 +
|
||||
(value.global ? 1 : 0) +
|
||||
(value.ignoreCase ? 1 : 0) +
|
||||
(value.multiline ? 1 : 0) +
|
||||
1
|
||||
);
|
||||
} else if (value instanceof BSONRegExp || value['_bsontype'] === 'BSONRegExp') {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
Buffer.byteLength(value.pattern, 'utf8') +
|
||||
1 +
|
||||
Buffer.byteLength(value.options, 'utf8') +
|
||||
1
|
||||
);
|
||||
} else {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
calculateObjectSize(value, serializeFunctions, ignoreUndefined) +
|
||||
1
|
||||
);
|
||||
}
|
||||
case 'function':
|
||||
// WTF for 0.4.X where typeof /someregexp/ === 'function'
|
||||
if (
|
||||
value instanceof RegExp ||
|
||||
Object.prototype.toString.call(value) === '[object RegExp]' ||
|
||||
String.call(value) === '[object RegExp]'
|
||||
) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
Buffer.byteLength(value.source, 'utf8') +
|
||||
1 +
|
||||
(value.global ? 1 : 0) +
|
||||
(value.ignoreCase ? 1 : 0) +
|
||||
(value.multiline ? 1 : 0) +
|
||||
1
|
||||
);
|
||||
} else {
|
||||
if (serializeFunctions && value.scope != null && Object.keys(value.scope).length > 0) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
4 +
|
||||
4 +
|
||||
Buffer.byteLength(normalizedFunctionString(value), 'utf8') +
|
||||
1 +
|
||||
calculateObjectSize(value.scope, serializeFunctions, ignoreUndefined)
|
||||
);
|
||||
} else if (serializeFunctions) {
|
||||
return (
|
||||
(name != null ? Buffer.byteLength(name, 'utf8') + 1 : 0) +
|
||||
1 +
|
||||
4 +
|
||||
Buffer.byteLength(normalizedFunctionString(value), 'utf8') +
|
||||
1
|
||||
);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
var BSON = {};
|
||||
|
||||
// BSON MAX VALUES
|
||||
BSON.BSON_INT32_MAX = 0x7fffffff;
|
||||
BSON.BSON_INT32_MIN = -0x80000000;
|
||||
|
||||
// JS MAX PRECISE VALUES
|
||||
BSON.JS_INT_MAX = 0x20000000000000; // Any integer up to 2^53 can be precisely represented by a double.
|
||||
BSON.JS_INT_MIN = -0x20000000000000; // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
module.exports = calculateObjectSize;
|
||||
Generated
Vendored
+780
@@ -0,0 +1,780 @@
|
||||
'use strict';
|
||||
|
||||
var Long = require('../long').Long,
|
||||
Double = require('../double').Double,
|
||||
Timestamp = require('../timestamp').Timestamp,
|
||||
ObjectID = require('../objectid').ObjectID,
|
||||
Symbol = require('../symbol').Symbol,
|
||||
Code = require('../code').Code,
|
||||
MinKey = require('../min_key').MinKey,
|
||||
MaxKey = require('../max_key').MaxKey,
|
||||
Decimal128 = require('../decimal128'),
|
||||
Int32 = require('../int_32'),
|
||||
DBRef = require('../db_ref').DBRef,
|
||||
BSONRegExp = require('../regexp').BSONRegExp,
|
||||
Binary = require('../binary').Binary;
|
||||
|
||||
var deserialize = function(buffer, options, isArray) {
|
||||
options = options == null ? {} : options;
|
||||
var index = options && options.index ? options.index : 0;
|
||||
// Read the document size
|
||||
var size =
|
||||
buffer[index] |
|
||||
(buffer[index + 1] << 8) |
|
||||
(buffer[index + 2] << 16) |
|
||||
(buffer[index + 3] << 24);
|
||||
|
||||
// Ensure buffer is valid size
|
||||
if (size < 5 || buffer.length < size || size + index > buffer.length) {
|
||||
throw new Error('corrupt bson message');
|
||||
}
|
||||
|
||||
// Illegal end value
|
||||
if (buffer[index + size - 1] !== 0) {
|
||||
throw new Error("One object, sized correctly, with a spot for an EOO, but the EOO isn't 0x00");
|
||||
}
|
||||
|
||||
// Start deserializtion
|
||||
return deserializeObject(buffer, index, options, isArray);
|
||||
};
|
||||
|
||||
var deserializeObject = function(buffer, index, options, isArray) {
|
||||
var evalFunctions = options['evalFunctions'] == null ? false : options['evalFunctions'];
|
||||
var cacheFunctions = options['cacheFunctions'] == null ? false : options['cacheFunctions'];
|
||||
var cacheFunctionsCrc32 =
|
||||
options['cacheFunctionsCrc32'] == null ? false : options['cacheFunctionsCrc32'];
|
||||
|
||||
if (!cacheFunctionsCrc32) var crc32 = null;
|
||||
|
||||
var fieldsAsRaw = options['fieldsAsRaw'] == null ? null : options['fieldsAsRaw'];
|
||||
|
||||
// Return raw bson buffer instead of parsing it
|
||||
var raw = options['raw'] == null ? false : options['raw'];
|
||||
|
||||
// Return BSONRegExp objects instead of native regular expressions
|
||||
var bsonRegExp = typeof options['bsonRegExp'] === 'boolean' ? options['bsonRegExp'] : false;
|
||||
|
||||
// Controls the promotion of values vs wrapper classes
|
||||
var promoteBuffers = options['promoteBuffers'] == null ? false : options['promoteBuffers'];
|
||||
var promoteLongs = options['promoteLongs'] == null ? true : options['promoteLongs'];
|
||||
var promoteValues = options['promoteValues'] == null ? true : options['promoteValues'];
|
||||
|
||||
// Set the start index
|
||||
var startIndex = index;
|
||||
|
||||
// Validate that we have at least 4 bytes of buffer
|
||||
if (buffer.length < 5) throw new Error('corrupt bson message < 5 bytes long');
|
||||
|
||||
// Read the document size
|
||||
var size =
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24);
|
||||
|
||||
// Ensure buffer is valid size
|
||||
if (size < 5 || size > buffer.length) throw new Error('corrupt bson message');
|
||||
|
||||
// Create holding object
|
||||
var object = isArray ? [] : {};
|
||||
// Used for arrays to skip having to perform utf8 decoding
|
||||
var arrayIndex = 0;
|
||||
|
||||
var done = false;
|
||||
|
||||
// While we have more left data left keep parsing
|
||||
// while (buffer[index + 1] !== 0) {
|
||||
while (!done) {
|
||||
// Read the type
|
||||
var elementType = buffer[index++];
|
||||
// If we get a zero it's the last byte, exit
|
||||
if (elementType === 0) break;
|
||||
|
||||
// Get the start search index
|
||||
var i = index;
|
||||
// Locate the end of the c string
|
||||
while (buffer[i] !== 0x00 && i < buffer.length) {
|
||||
i++;
|
||||
}
|
||||
|
||||
// If are at the end of the buffer there is a problem with the document
|
||||
if (i >= buffer.length) throw new Error('Bad BSON Document: illegal CString');
|
||||
var name = isArray ? arrayIndex++ : buffer.toString('utf8', index, i);
|
||||
|
||||
index = i + 1;
|
||||
|
||||
if (elementType === BSON.BSON_DATA_STRING) {
|
||||
var stringSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
if (
|
||||
stringSize <= 0 ||
|
||||
stringSize > buffer.length - index ||
|
||||
buffer[index + stringSize - 1] !== 0
|
||||
)
|
||||
throw new Error('bad string length in bson');
|
||||
object[name] = buffer.toString('utf8', index, index + stringSize - 1);
|
||||
index = index + stringSize;
|
||||
} else if (elementType === BSON.BSON_DATA_OID) {
|
||||
var oid = new Buffer(12);
|
||||
buffer.copy(oid, 0, index, index + 12);
|
||||
object[name] = new ObjectID(oid);
|
||||
index = index + 12;
|
||||
} else if (elementType === BSON.BSON_DATA_INT && promoteValues === false) {
|
||||
object[name] = new Int32(
|
||||
buffer[index++] | (buffer[index++] << 8) | (buffer[index++] << 16) | (buffer[index++] << 24)
|
||||
);
|
||||
} else if (elementType === BSON.BSON_DATA_INT) {
|
||||
object[name] =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
} else if (elementType === BSON.BSON_DATA_NUMBER && promoteValues === false) {
|
||||
object[name] = new Double(buffer.readDoubleLE(index));
|
||||
index = index + 8;
|
||||
} else if (elementType === BSON.BSON_DATA_NUMBER) {
|
||||
object[name] = buffer.readDoubleLE(index);
|
||||
index = index + 8;
|
||||
} else if (elementType === BSON.BSON_DATA_DATE) {
|
||||
var lowBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
var highBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
object[name] = new Date(new Long(lowBits, highBits).toNumber());
|
||||
} else if (elementType === BSON.BSON_DATA_BOOLEAN) {
|
||||
if (buffer[index] !== 0 && buffer[index] !== 1) throw new Error('illegal boolean type value');
|
||||
object[name] = buffer[index++] === 1;
|
||||
} else if (elementType === BSON.BSON_DATA_OBJECT) {
|
||||
var _index = index;
|
||||
var objectSize =
|
||||
buffer[index] |
|
||||
(buffer[index + 1] << 8) |
|
||||
(buffer[index + 2] << 16) |
|
||||
(buffer[index + 3] << 24);
|
||||
if (objectSize <= 0 || objectSize > buffer.length - index)
|
||||
throw new Error('bad embedded document length in bson');
|
||||
|
||||
// We have a raw value
|
||||
if (raw) {
|
||||
object[name] = buffer.slice(index, index + objectSize);
|
||||
} else {
|
||||
object[name] = deserializeObject(buffer, _index, options, false);
|
||||
}
|
||||
|
||||
index = index + objectSize;
|
||||
} else if (elementType === BSON.BSON_DATA_ARRAY) {
|
||||
_index = index;
|
||||
objectSize =
|
||||
buffer[index] |
|
||||
(buffer[index + 1] << 8) |
|
||||
(buffer[index + 2] << 16) |
|
||||
(buffer[index + 3] << 24);
|
||||
var arrayOptions = options;
|
||||
|
||||
// Stop index
|
||||
var stopIndex = index + objectSize;
|
||||
|
||||
// All elements of array to be returned as raw bson
|
||||
if (fieldsAsRaw && fieldsAsRaw[name]) {
|
||||
arrayOptions = {};
|
||||
for (var n in options) arrayOptions[n] = options[n];
|
||||
arrayOptions['raw'] = true;
|
||||
}
|
||||
|
||||
object[name] = deserializeObject(buffer, _index, arrayOptions, true);
|
||||
index = index + objectSize;
|
||||
|
||||
if (buffer[index - 1] !== 0) throw new Error('invalid array terminator byte');
|
||||
if (index !== stopIndex) throw new Error('corrupted array bson');
|
||||
} else if (elementType === BSON.BSON_DATA_UNDEFINED) {
|
||||
object[name] = undefined;
|
||||
} else if (elementType === BSON.BSON_DATA_NULL) {
|
||||
object[name] = null;
|
||||
} else if (elementType === BSON.BSON_DATA_LONG) {
|
||||
// Unpack the low and high bits
|
||||
lowBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
highBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
var long = new Long(lowBits, highBits);
|
||||
// Promote the long if possible
|
||||
if (promoteLongs && promoteValues === true) {
|
||||
object[name] =
|
||||
long.lessThanOrEqual(JS_INT_MAX_LONG) && long.greaterThanOrEqual(JS_INT_MIN_LONG)
|
||||
? long.toNumber()
|
||||
: long;
|
||||
} else {
|
||||
object[name] = long;
|
||||
}
|
||||
} else if (elementType === BSON.BSON_DATA_DECIMAL128) {
|
||||
// Buffer to contain the decimal bytes
|
||||
var bytes = new Buffer(16);
|
||||
// Copy the next 16 bytes into the bytes buffer
|
||||
buffer.copy(bytes, 0, index, index + 16);
|
||||
// Update index
|
||||
index = index + 16;
|
||||
// Assign the new Decimal128 value
|
||||
var decimal128 = new Decimal128(bytes);
|
||||
// If we have an alternative mapper use that
|
||||
object[name] = decimal128.toObject ? decimal128.toObject() : decimal128;
|
||||
} else if (elementType === BSON.BSON_DATA_BINARY) {
|
||||
var binarySize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
var totalBinarySize = binarySize;
|
||||
var subType = buffer[index++];
|
||||
|
||||
// Did we have a negative binary size, throw
|
||||
if (binarySize < 0) throw new Error('Negative binary type element size found');
|
||||
|
||||
// Is the length longer than the document
|
||||
if (binarySize > buffer.length) throw new Error('Binary type size larger than document size');
|
||||
|
||||
// Decode as raw Buffer object if options specifies it
|
||||
if (buffer['slice'] != null) {
|
||||
// If we have subtype 2 skip the 4 bytes for the size
|
||||
if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
|
||||
binarySize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
if (binarySize < 0)
|
||||
throw new Error('Negative binary type element size found for subtype 0x02');
|
||||
if (binarySize > totalBinarySize - 4)
|
||||
throw new Error('Binary type with subtype 0x02 contains to long binary size');
|
||||
if (binarySize < totalBinarySize - 4)
|
||||
throw new Error('Binary type with subtype 0x02 contains to short binary size');
|
||||
}
|
||||
|
||||
if (promoteBuffers && promoteValues) {
|
||||
object[name] = buffer.slice(index, index + binarySize);
|
||||
} else {
|
||||
object[name] = new Binary(buffer.slice(index, index + binarySize), subType);
|
||||
}
|
||||
} else {
|
||||
var _buffer =
|
||||
typeof Uint8Array !== 'undefined'
|
||||
? new Uint8Array(new ArrayBuffer(binarySize))
|
||||
: new Array(binarySize);
|
||||
// If we have subtype 2 skip the 4 bytes for the size
|
||||
if (subType === Binary.SUBTYPE_BYTE_ARRAY) {
|
||||
binarySize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
if (binarySize < 0)
|
||||
throw new Error('Negative binary type element size found for subtype 0x02');
|
||||
if (binarySize > totalBinarySize - 4)
|
||||
throw new Error('Binary type with subtype 0x02 contains to long binary size');
|
||||
if (binarySize < totalBinarySize - 4)
|
||||
throw new Error('Binary type with subtype 0x02 contains to short binary size');
|
||||
}
|
||||
|
||||
// Copy the data
|
||||
for (i = 0; i < binarySize; i++) {
|
||||
_buffer[i] = buffer[index + i];
|
||||
}
|
||||
|
||||
if (promoteBuffers && promoteValues) {
|
||||
object[name] = _buffer;
|
||||
} else {
|
||||
object[name] = new Binary(_buffer, subType);
|
||||
}
|
||||
}
|
||||
|
||||
// Update the index
|
||||
index = index + binarySize;
|
||||
} else if (elementType === BSON.BSON_DATA_REGEXP && bsonRegExp === false) {
|
||||
// Get the start search index
|
||||
i = index;
|
||||
// Locate the end of the c string
|
||||
while (buffer[i] !== 0x00 && i < buffer.length) {
|
||||
i++;
|
||||
}
|
||||
// If are at the end of the buffer there is a problem with the document
|
||||
if (i >= buffer.length) throw new Error('Bad BSON Document: illegal CString');
|
||||
// Return the C string
|
||||
var source = buffer.toString('utf8', index, i);
|
||||
// Create the regexp
|
||||
index = i + 1;
|
||||
|
||||
// Get the start search index
|
||||
i = index;
|
||||
// Locate the end of the c string
|
||||
while (buffer[i] !== 0x00 && i < buffer.length) {
|
||||
i++;
|
||||
}
|
||||
// If are at the end of the buffer there is a problem with the document
|
||||
if (i >= buffer.length) throw new Error('Bad BSON Document: illegal CString');
|
||||
// Return the C string
|
||||
var regExpOptions = buffer.toString('utf8', index, i);
|
||||
index = i + 1;
|
||||
|
||||
// For each option add the corresponding one for javascript
|
||||
var optionsArray = new Array(regExpOptions.length);
|
||||
|
||||
// Parse options
|
||||
for (i = 0; i < regExpOptions.length; i++) {
|
||||
switch (regExpOptions[i]) {
|
||||
case 'm':
|
||||
optionsArray[i] = 'm';
|
||||
break;
|
||||
case 's':
|
||||
optionsArray[i] = 'g';
|
||||
break;
|
||||
case 'i':
|
||||
optionsArray[i] = 'i';
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
object[name] = new RegExp(source, optionsArray.join(''));
|
||||
} else if (elementType === BSON.BSON_DATA_REGEXP && bsonRegExp === true) {
|
||||
// Get the start search index
|
||||
i = index;
|
||||
// Locate the end of the c string
|
||||
while (buffer[i] !== 0x00 && i < buffer.length) {
|
||||
i++;
|
||||
}
|
||||
// If are at the end of the buffer there is a problem with the document
|
||||
if (i >= buffer.length) throw new Error('Bad BSON Document: illegal CString');
|
||||
// Return the C string
|
||||
source = buffer.toString('utf8', index, i);
|
||||
index = i + 1;
|
||||
|
||||
// Get the start search index
|
||||
i = index;
|
||||
// Locate the end of the c string
|
||||
while (buffer[i] !== 0x00 && i < buffer.length) {
|
||||
i++;
|
||||
}
|
||||
// If are at the end of the buffer there is a problem with the document
|
||||
if (i >= buffer.length) throw new Error('Bad BSON Document: illegal CString');
|
||||
// Return the C string
|
||||
regExpOptions = buffer.toString('utf8', index, i);
|
||||
index = i + 1;
|
||||
|
||||
// Set the object
|
||||
object[name] = new BSONRegExp(source, regExpOptions);
|
||||
} else if (elementType === BSON.BSON_DATA_SYMBOL) {
|
||||
stringSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
if (
|
||||
stringSize <= 0 ||
|
||||
stringSize > buffer.length - index ||
|
||||
buffer[index + stringSize - 1] !== 0
|
||||
)
|
||||
throw new Error('bad string length in bson');
|
||||
object[name] = new Symbol(buffer.toString('utf8', index, index + stringSize - 1));
|
||||
index = index + stringSize;
|
||||
} else if (elementType === BSON.BSON_DATA_TIMESTAMP) {
|
||||
lowBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
highBits =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
object[name] = new Timestamp(lowBits, highBits);
|
||||
} else if (elementType === BSON.BSON_DATA_MIN_KEY) {
|
||||
object[name] = new MinKey();
|
||||
} else if (elementType === BSON.BSON_DATA_MAX_KEY) {
|
||||
object[name] = new MaxKey();
|
||||
} else if (elementType === BSON.BSON_DATA_CODE) {
|
||||
stringSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
if (
|
||||
stringSize <= 0 ||
|
||||
stringSize > buffer.length - index ||
|
||||
buffer[index + stringSize - 1] !== 0
|
||||
)
|
||||
throw new Error('bad string length in bson');
|
||||
var functionString = buffer.toString('utf8', index, index + stringSize - 1);
|
||||
|
||||
// If we are evaluating the functions
|
||||
if (evalFunctions) {
|
||||
// If we have cache enabled let's look for the md5 of the function in the cache
|
||||
if (cacheFunctions) {
|
||||
var hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString;
|
||||
// Got to do this to avoid V8 deoptimizing the call due to finding eval
|
||||
object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
|
||||
} else {
|
||||
object[name] = isolateEval(functionString);
|
||||
}
|
||||
} else {
|
||||
object[name] = new Code(functionString);
|
||||
}
|
||||
|
||||
// Update parse index position
|
||||
index = index + stringSize;
|
||||
} else if (elementType === BSON.BSON_DATA_CODE_W_SCOPE) {
|
||||
var totalSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
|
||||
// Element cannot be shorter than totalSize + stringSize + documentSize + terminator
|
||||
if (totalSize < 4 + 4 + 4 + 1) {
|
||||
throw new Error('code_w_scope total size shorter minimum expected length');
|
||||
}
|
||||
|
||||
// Get the code string size
|
||||
stringSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
// Check if we have a valid string
|
||||
if (
|
||||
stringSize <= 0 ||
|
||||
stringSize > buffer.length - index ||
|
||||
buffer[index + stringSize - 1] !== 0
|
||||
)
|
||||
throw new Error('bad string length in bson');
|
||||
|
||||
// Javascript function
|
||||
functionString = buffer.toString('utf8', index, index + stringSize - 1);
|
||||
// Update parse index position
|
||||
index = index + stringSize;
|
||||
// Parse the element
|
||||
_index = index;
|
||||
// Decode the size of the object document
|
||||
objectSize =
|
||||
buffer[index] |
|
||||
(buffer[index + 1] << 8) |
|
||||
(buffer[index + 2] << 16) |
|
||||
(buffer[index + 3] << 24);
|
||||
// Decode the scope object
|
||||
var scopeObject = deserializeObject(buffer, _index, options, false);
|
||||
// Adjust the index
|
||||
index = index + objectSize;
|
||||
|
||||
// Check if field length is to short
|
||||
if (totalSize < 4 + 4 + objectSize + stringSize) {
|
||||
throw new Error('code_w_scope total size is to short, truncating scope');
|
||||
}
|
||||
|
||||
// Check if totalSize field is to long
|
||||
if (totalSize > 4 + 4 + objectSize + stringSize) {
|
||||
throw new Error('code_w_scope total size is to long, clips outer document');
|
||||
}
|
||||
|
||||
// If we are evaluating the functions
|
||||
if (evalFunctions) {
|
||||
// If we have cache enabled let's look for the md5 of the function in the cache
|
||||
if (cacheFunctions) {
|
||||
hash = cacheFunctionsCrc32 ? crc32(functionString) : functionString;
|
||||
// Got to do this to avoid V8 deoptimizing the call due to finding eval
|
||||
object[name] = isolateEvalWithHash(functionCache, hash, functionString, object);
|
||||
} else {
|
||||
object[name] = isolateEval(functionString);
|
||||
}
|
||||
|
||||
object[name].scope = scopeObject;
|
||||
} else {
|
||||
object[name] = new Code(functionString, scopeObject);
|
||||
}
|
||||
} else if (elementType === BSON.BSON_DATA_DBPOINTER) {
|
||||
// Get the code string size
|
||||
stringSize =
|
||||
buffer[index++] |
|
||||
(buffer[index++] << 8) |
|
||||
(buffer[index++] << 16) |
|
||||
(buffer[index++] << 24);
|
||||
// Check if we have a valid string
|
||||
if (
|
||||
stringSize <= 0 ||
|
||||
stringSize > buffer.length - index ||
|
||||
buffer[index + stringSize - 1] !== 0
|
||||
)
|
||||
throw new Error('bad string length in bson');
|
||||
// Namespace
|
||||
var namespace = buffer.toString('utf8', index, index + stringSize - 1);
|
||||
// Update parse index position
|
||||
index = index + stringSize;
|
||||
|
||||
// Read the oid
|
||||
var oidBuffer = new Buffer(12);
|
||||
buffer.copy(oidBuffer, 0, index, index + 12);
|
||||
oid = new ObjectID(oidBuffer);
|
||||
|
||||
// Update the index
|
||||
index = index + 12;
|
||||
|
||||
// Split the namespace
|
||||
var parts = namespace.split('.');
|
||||
var db = parts.shift();
|
||||
var collection = parts.join('.');
|
||||
// Upgrade to DBRef type
|
||||
object[name] = new DBRef(collection, oid, db);
|
||||
} else {
|
||||
throw new Error(
|
||||
'Detected unknown BSON type ' +
|
||||
elementType.toString(16) +
|
||||
' for fieldname "' +
|
||||
name +
|
||||
'", are you using the latest BSON parser'
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// Check if the deserialization was against a valid array/object
|
||||
if (size !== index - startIndex) {
|
||||
if (isArray) throw new Error('corrupt array bson');
|
||||
throw new Error('corrupt object bson');
|
||||
}
|
||||
|
||||
// Check if we have a db ref object
|
||||
if (object['$id'] != null) object = new DBRef(object['$ref'], object['$id'], object['$db']);
|
||||
return object;
|
||||
};
|
||||
|
||||
/**
|
||||
* Ensure eval is isolated.
|
||||
*
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
var isolateEvalWithHash = function(functionCache, hash, functionString, object) {
|
||||
// Contains the value we are going to set
|
||||
var value = null;
|
||||
|
||||
// Check for cache hit, eval if missing and return cached function
|
||||
if (functionCache[hash] == null) {
|
||||
eval('value = ' + functionString);
|
||||
functionCache[hash] = value;
|
||||
}
|
||||
// Set the object
|
||||
return functionCache[hash].bind(object);
|
||||
};
|
||||
|
||||
/**
|
||||
* Ensure eval is isolated.
|
||||
*
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
var isolateEval = function(functionString) {
|
||||
// Contains the value we are going to set
|
||||
var value = null;
|
||||
// Eval the function
|
||||
eval('value = ' + functionString);
|
||||
return value;
|
||||
};
|
||||
|
||||
var BSON = {};
|
||||
|
||||
/**
|
||||
* Contains the function cache if we have that enable to allow for avoiding the eval step on each deserialization, comparison is by md5
|
||||
*
|
||||
* @ignore
|
||||
* @api private
|
||||
*/
|
||||
var functionCache = (BSON.functionCache = {});
|
||||
|
||||
/**
|
||||
* Number BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_NUMBER
|
||||
**/
|
||||
BSON.BSON_DATA_NUMBER = 1;
|
||||
/**
|
||||
* String BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_STRING
|
||||
**/
|
||||
BSON.BSON_DATA_STRING = 2;
|
||||
/**
|
||||
* Object BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_OBJECT
|
||||
**/
|
||||
BSON.BSON_DATA_OBJECT = 3;
|
||||
/**
|
||||
* Array BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_ARRAY
|
||||
**/
|
||||
BSON.BSON_DATA_ARRAY = 4;
|
||||
/**
|
||||
* Binary BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_BINARY
|
||||
**/
|
||||
BSON.BSON_DATA_BINARY = 5;
|
||||
/**
|
||||
* Binary BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_UNDEFINED
|
||||
**/
|
||||
BSON.BSON_DATA_UNDEFINED = 6;
|
||||
/**
|
||||
* ObjectID BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_OID
|
||||
**/
|
||||
BSON.BSON_DATA_OID = 7;
|
||||
/**
|
||||
* Boolean BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_BOOLEAN
|
||||
**/
|
||||
BSON.BSON_DATA_BOOLEAN = 8;
|
||||
/**
|
||||
* Date BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_DATE
|
||||
**/
|
||||
BSON.BSON_DATA_DATE = 9;
|
||||
/**
|
||||
* null BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_NULL
|
||||
**/
|
||||
BSON.BSON_DATA_NULL = 10;
|
||||
/**
|
||||
* RegExp BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_REGEXP
|
||||
**/
|
||||
BSON.BSON_DATA_REGEXP = 11;
|
||||
/**
|
||||
* Code BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_DBPOINTER
|
||||
**/
|
||||
BSON.BSON_DATA_DBPOINTER = 12;
|
||||
/**
|
||||
* Code BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_CODE
|
||||
**/
|
||||
BSON.BSON_DATA_CODE = 13;
|
||||
/**
|
||||
* Symbol BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_SYMBOL
|
||||
**/
|
||||
BSON.BSON_DATA_SYMBOL = 14;
|
||||
/**
|
||||
* Code with Scope BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_CODE_W_SCOPE
|
||||
**/
|
||||
BSON.BSON_DATA_CODE_W_SCOPE = 15;
|
||||
/**
|
||||
* 32 bit Integer BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_INT
|
||||
**/
|
||||
BSON.BSON_DATA_INT = 16;
|
||||
/**
|
||||
* Timestamp BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_TIMESTAMP
|
||||
**/
|
||||
BSON.BSON_DATA_TIMESTAMP = 17;
|
||||
/**
|
||||
* Long BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_LONG
|
||||
**/
|
||||
BSON.BSON_DATA_LONG = 18;
|
||||
/**
|
||||
* Long BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_DECIMAL128
|
||||
**/
|
||||
BSON.BSON_DATA_DECIMAL128 = 19;
|
||||
/**
|
||||
* MinKey BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_MIN_KEY
|
||||
**/
|
||||
BSON.BSON_DATA_MIN_KEY = 0xff;
|
||||
/**
|
||||
* MaxKey BSON Type
|
||||
*
|
||||
* @classconstant BSON_DATA_MAX_KEY
|
||||
**/
|
||||
BSON.BSON_DATA_MAX_KEY = 0x7f;
|
||||
|
||||
/**
|
||||
* Binary Default Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_DEFAULT
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_DEFAULT = 0;
|
||||
/**
|
||||
* Binary Function Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_FUNCTION
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_FUNCTION = 1;
|
||||
/**
|
||||
* Binary Byte Array Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_BYTE_ARRAY
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_BYTE_ARRAY = 2;
|
||||
/**
|
||||
* Binary UUID Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_UUID
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_UUID = 3;
|
||||
/**
|
||||
* Binary MD5 Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_MD5
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_MD5 = 4;
|
||||
/**
|
||||
* Binary User Defined Type
|
||||
*
|
||||
* @classconstant BSON_BINARY_SUBTYPE_USER_DEFINED
|
||||
**/
|
||||
BSON.BSON_BINARY_SUBTYPE_USER_DEFINED = 128;
|
||||
|
||||
// BSON MAX VALUES
|
||||
BSON.BSON_INT32_MAX = 0x7fffffff;
|
||||
BSON.BSON_INT32_MIN = -0x80000000;
|
||||
|
||||
BSON.BSON_INT64_MAX = Math.pow(2, 63) - 1;
|
||||
BSON.BSON_INT64_MIN = -Math.pow(2, 63);
|
||||
|
||||
// JS MAX PRECISE VALUES
|
||||
BSON.JS_INT_MAX = 0x20000000000000; // Any integer up to 2^53 can be precisely represented by a double.
|
||||
BSON.JS_INT_MIN = -0x20000000000000; // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
// Internal long versions
|
||||
var JS_INT_MAX_LONG = Long.fromNumber(0x20000000000000); // Any integer up to 2^53 can be precisely represented by a double.
|
||||
var JS_INT_MIN_LONG = Long.fromNumber(-0x20000000000000); // Any integer down to -2^53 can be precisely represented by a double.
|
||||
|
||||
module.exports = deserialize;
|
||||
+1183
File diff suppressed because it is too large.
Load diff
+14
@@ -0,0 +1,14 @@
|
||||
'use strict';
|
||||
|
||||
/**
|
||||
* Normalizes our expected stringified form of a function across versions of node
|
||||
* @param {Function} fn The function to stringify
|
||||
*/
|
||||
function normalizedFunctionString(fn) {
|
||||
return fn.toString().replace(/function *\(/, 'function (');
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
normalizedFunctionString: normalizedFunctionString
|
||||
};
|
||||
|
||||
+33
@@ -0,0 +1,33 @@
|
||||
/**
|
||||
* A class representation of the BSON RegExp type.
|
||||
*
|
||||
* @class
|
||||
* @return {BSONRegExp} A MinKey instance
|
||||
*/
|
||||
function BSONRegExp(pattern, options) {
|
||||
if (!(this instanceof BSONRegExp)) return new BSONRegExp();
|
||||
|
||||
// Execute
|
||||
this._bsontype = 'BSONRegExp';
|
||||
this.pattern = pattern || '';
|
||||
this.options = options || '';
|
||||
|
||||
// Validate options
|
||||
for (var i = 0; i < this.options.length; i++) {
|
||||
if (
|
||||
!(
|
||||
this.options[i] === 'i' ||
|
||||
this.options[i] === 'm' ||
|
||||
this.options[i] === 'x' ||
|
||||
this.options[i] === 'l' ||
|
||||
this.options[i] === 's' ||
|
||||
this.options[i] === 'u'
|
||||
)
|
||||
) {
|
||||
throw new Error('the regular expression options [' + this.options[i] + '] is not supported');
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
module.exports = BSONRegExp;
|
||||
module.exports.BSONRegExp = BSONRegExp;
|
||||
+50
@@ -0,0 +1,50 @@
|
||||
// Custom inspect property name / symbol.
|
||||
var inspect = Buffer ? require('util').inspect.custom || 'inspect' : 'inspect';
|
||||
|
||||
/**
|
||||
* A class representation of the BSON Symbol type.
|
||||
*
|
||||
* @class
|
||||
* @deprecated
|
||||
* @param {string} value the string representing the symbol.
|
||||
* @return {Symbol}
|
||||
*/
|
||||
function Symbol(value) {
|
||||
if (!(this instanceof Symbol)) return new Symbol(value);
|
||||
this._bsontype = 'Symbol';
|
||||
this.value = value;
|
||||
}
|
||||
|
||||
/**
|
||||
* Access the wrapped string value.
|
||||
*
|
||||
* @method
|
||||
* @return {String} returns the wrapped string.
|
||||
*/
|
||||
Symbol.prototype.valueOf = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Symbol.prototype.toString = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Symbol.prototype[inspect] = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
/**
|
||||
* @ignore
|
||||
*/
|
||||
Symbol.prototype.toJSON = function() {
|
||||
return this.value;
|
||||
};
|
||||
|
||||
module.exports = Symbol;
|
||||
module.exports.Symbol = Symbol;
|
||||
+854
@@ -0,0 +1,854 @@
|
||||
// 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 2009 Google Inc. All Rights Reserved
|
||||
|
||||
/**
|
||||
* This type is for INTERNAL use in MongoDB only and should not be used in applications.
|
||||
* The appropriate corresponding type is the JavaScript Date type.
|
||||
*
|
||||
* Defines a Timestamp class for representing a 64-bit two's-complement
|
||||
* integer value, which faithfully simulates the behavior of a Java "Timestamp". This
|
||||
* implementation is derived from TimestampLib in GWT.
|
||||
*
|
||||
* Constructs a 64-bit two's-complement integer, given its low and high 32-bit
|
||||
* values as *signed* integers. See the from* functions below for more
|
||||
* convenient ways of constructing Timestamps.
|
||||
*
|
||||
* The internal representation of a Timestamp is the two given signed, 32-bit values.
|
||||
* We use 32-bit pieces because these are the size of integers on which
|
||||
* Javascript performs bit-operations. For operations like addition and
|
||||
* multiplication, we split each number into 16-bit pieces, which can easily be
|
||||
* multiplied within Javascript's floating-point representation without overflow
|
||||
* or change in sign.
|
||||
*
|
||||
* In the algorithms below, we frequently reduce the negative case to the
|
||||
* positive case by negating the input(s) and then post-processing the result.
|
||||
* Note that we must ALWAYS check specially whether those values are MIN_VALUE
|
||||
* (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
|
||||
* a positive number, it overflows back into a negative). Not handling this
|
||||
* case would often result in infinite recursion.
|
||||
*
|
||||
* @class
|
||||
* @param {number} low the low (signed) 32 bits of the Timestamp.
|
||||
* @param {number} high the high (signed) 32 bits of the Timestamp.
|
||||
*/
|
||||
function Timestamp(low, high) {
|
||||
if (!(this instanceof Timestamp)) return new Timestamp(low, high);
|
||||
this._bsontype = 'Timestamp';
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
this.low_ = low | 0; // force into 32 signed bits.
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
this.high_ = high | 0; // force into 32 signed bits.
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the int value.
|
||||
*
|
||||
* @return {number} the value, assuming it is a 32-bit integer.
|
||||
*/
|
||||
Timestamp.prototype.toInt = function() {
|
||||
return this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the Number value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the closest floating-point representation to this value.
|
||||
*/
|
||||
Timestamp.prototype.toNumber = function() {
|
||||
return this.high_ * Timestamp.TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the JSON value.
|
||||
*
|
||||
* @method
|
||||
* @return {string} the JSON representation.
|
||||
*/
|
||||
Timestamp.prototype.toJSON = function() {
|
||||
return this.toString();
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the String value.
|
||||
*
|
||||
* @method
|
||||
* @param {number} [opt_radix] the radix in which the text should be written.
|
||||
* @return {string} the textual representation of this value.
|
||||
*/
|
||||
Timestamp.prototype.toString = function(opt_radix) {
|
||||
var radix = opt_radix || 10;
|
||||
if (radix < 2 || 36 < radix) {
|
||||
throw Error('radix out of range: ' + radix);
|
||||
}
|
||||
|
||||
if (this.isZero()) {
|
||||
return '0';
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (this.equals(Timestamp.MIN_VALUE)) {
|
||||
// We need to change the Timestamp value before it can be negated, so we remove
|
||||
// the bottom-most digit in this base and then recurse to do the rest.
|
||||
var radixTimestamp = Timestamp.fromNumber(radix);
|
||||
var div = this.div(radixTimestamp);
|
||||
var rem = div.multiply(radixTimestamp).subtract(this);
|
||||
return div.toString(radix) + rem.toInt().toString(radix);
|
||||
} else {
|
||||
return '-' + this.negate().toString(radix);
|
||||
}
|
||||
}
|
||||
|
||||
// Do several (6) digits each time through the loop, so as to
|
||||
// minimize the calls to the very expensive emulated div.
|
||||
var radixToPower = Timestamp.fromNumber(Math.pow(radix, 6));
|
||||
|
||||
rem = this;
|
||||
var result = '';
|
||||
|
||||
while (!rem.isZero()) {
|
||||
var remDiv = rem.div(radixToPower);
|
||||
var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();
|
||||
var digits = intval.toString(radix);
|
||||
|
||||
rem = remDiv;
|
||||
if (rem.isZero()) {
|
||||
return digits + result;
|
||||
} else {
|
||||
while (digits.length < 6) {
|
||||
digits = '0' + digits;
|
||||
}
|
||||
result = '' + digits + result;
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the high 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the high 32-bits as a signed value.
|
||||
*/
|
||||
Timestamp.prototype.getHighBits = function() {
|
||||
return this.high_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the low 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the low 32-bits as a signed value.
|
||||
*/
|
||||
Timestamp.prototype.getLowBits = function() {
|
||||
return this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return the low unsigned 32-bits value.
|
||||
*
|
||||
* @method
|
||||
* @return {number} the low 32-bits as an unsigned value.
|
||||
*/
|
||||
Timestamp.prototype.getLowBitsUnsigned = function() {
|
||||
return this.low_ >= 0 ? this.low_ : Timestamp.TWO_PWR_32_DBL_ + this.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the number of bits needed to represent the absolute value of this Timestamp.
|
||||
*
|
||||
* @method
|
||||
* @return {number} Returns the number of bits needed to represent the absolute value of this Timestamp.
|
||||
*/
|
||||
Timestamp.prototype.getNumBitsAbs = function() {
|
||||
if (this.isNegative()) {
|
||||
if (this.equals(Timestamp.MIN_VALUE)) {
|
||||
return 64;
|
||||
} else {
|
||||
return this.negate().getNumBitsAbs();
|
||||
}
|
||||
} else {
|
||||
var val = this.high_ !== 0 ? this.high_ : this.low_;
|
||||
for (var bit = 31; bit > 0; bit--) {
|
||||
if ((val & (1 << bit)) !== 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
return this.high_ !== 0 ? bit + 33 : bit + 1;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is zero.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is zero.
|
||||
*/
|
||||
Timestamp.prototype.isZero = function() {
|
||||
return this.high_ === 0 && this.low_ === 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is negative.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is negative.
|
||||
*/
|
||||
Timestamp.prototype.isNegative = function() {
|
||||
return this.high_ < 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this value is odd.
|
||||
*
|
||||
* @method
|
||||
* @return {boolean} whether this value is odd.
|
||||
*/
|
||||
Timestamp.prototype.isOdd = function() {
|
||||
return (this.low_ & 1) === 1;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp equals the other
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp equals the other
|
||||
*/
|
||||
Timestamp.prototype.equals = function(other) {
|
||||
return this.high_ === other.high_ && this.low_ === other.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp does not equal the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp does not equal the other.
|
||||
*/
|
||||
Timestamp.prototype.notEquals = function(other) {
|
||||
return this.high_ !== other.high_ || this.low_ !== other.low_;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp is less than the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp is less than the other.
|
||||
*/
|
||||
Timestamp.prototype.lessThan = function(other) {
|
||||
return this.compare(other) < 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp is less than or equal to the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp is less than or equal to the other.
|
||||
*/
|
||||
Timestamp.prototype.lessThanOrEqual = function(other) {
|
||||
return this.compare(other) <= 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp is greater than the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp is greater than the other.
|
||||
*/
|
||||
Timestamp.prototype.greaterThan = function(other) {
|
||||
return this.compare(other) > 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Return whether this Timestamp is greater than or equal to the other.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} whether this Timestamp is greater than or equal to the other.
|
||||
*/
|
||||
Timestamp.prototype.greaterThanOrEqual = function(other) {
|
||||
return this.compare(other) >= 0;
|
||||
};
|
||||
|
||||
/**
|
||||
* Compares this Timestamp with the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to compare against.
|
||||
* @return {boolean} 0 if they are the same, 1 if the this is greater, and -1 if the given one is greater.
|
||||
*/
|
||||
Timestamp.prototype.compare = function(other) {
|
||||
if (this.equals(other)) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
var thisNeg = this.isNegative();
|
||||
var otherNeg = other.isNegative();
|
||||
if (thisNeg && !otherNeg) {
|
||||
return -1;
|
||||
}
|
||||
if (!thisNeg && otherNeg) {
|
||||
return 1;
|
||||
}
|
||||
|
||||
// at this point, the signs are the same, so subtraction will not overflow
|
||||
if (this.subtract(other).isNegative()) {
|
||||
return -1;
|
||||
} else {
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* The negation of this value.
|
||||
*
|
||||
* @method
|
||||
* @return {Timestamp} the negation of this value.
|
||||
*/
|
||||
Timestamp.prototype.negate = function() {
|
||||
if (this.equals(Timestamp.MIN_VALUE)) {
|
||||
return Timestamp.MIN_VALUE;
|
||||
} else {
|
||||
return this.not().add(Timestamp.ONE);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the sum of this and the given Timestamp.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to add to this one.
|
||||
* @return {Timestamp} the sum of this and the given Timestamp.
|
||||
*/
|
||||
Timestamp.prototype.add = function(other) {
|
||||
// Divide each number into 4 chunks of 16 bits, and then sum the chunks.
|
||||
|
||||
var a48 = this.high_ >>> 16;
|
||||
var a32 = this.high_ & 0xffff;
|
||||
var a16 = this.low_ >>> 16;
|
||||
var a00 = this.low_ & 0xffff;
|
||||
|
||||
var b48 = other.high_ >>> 16;
|
||||
var b32 = other.high_ & 0xffff;
|
||||
var b16 = other.low_ >>> 16;
|
||||
var b00 = other.low_ & 0xffff;
|
||||
|
||||
var c48 = 0,
|
||||
c32 = 0,
|
||||
c16 = 0,
|
||||
c00 = 0;
|
||||
c00 += a00 + b00;
|
||||
c16 += c00 >>> 16;
|
||||
c00 &= 0xffff;
|
||||
c16 += a16 + b16;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c32 += a32 + b32;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c48 += a48 + b48;
|
||||
c48 &= 0xffff;
|
||||
return Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the difference of this and the given Timestamp.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to subtract from this.
|
||||
* @return {Timestamp} the difference of this and the given Timestamp.
|
||||
*/
|
||||
Timestamp.prototype.subtract = function(other) {
|
||||
return this.add(other.negate());
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the product of this and the given Timestamp.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp to multiply with this.
|
||||
* @return {Timestamp} the product of this and the other.
|
||||
*/
|
||||
Timestamp.prototype.multiply = function(other) {
|
||||
if (this.isZero()) {
|
||||
return Timestamp.ZERO;
|
||||
} else if (other.isZero()) {
|
||||
return Timestamp.ZERO;
|
||||
}
|
||||
|
||||
if (this.equals(Timestamp.MIN_VALUE)) {
|
||||
return other.isOdd() ? Timestamp.MIN_VALUE : Timestamp.ZERO;
|
||||
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
||||
return this.isOdd() ? Timestamp.MIN_VALUE : Timestamp.ZERO;
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (other.isNegative()) {
|
||||
return this.negate().multiply(other.negate());
|
||||
} else {
|
||||
return this.negate()
|
||||
.multiply(other)
|
||||
.negate();
|
||||
}
|
||||
} else if (other.isNegative()) {
|
||||
return this.multiply(other.negate()).negate();
|
||||
}
|
||||
|
||||
// If both Timestamps are small, use float multiplication
|
||||
if (this.lessThan(Timestamp.TWO_PWR_24_) && other.lessThan(Timestamp.TWO_PWR_24_)) {
|
||||
return Timestamp.fromNumber(this.toNumber() * other.toNumber());
|
||||
}
|
||||
|
||||
// Divide each Timestamp into 4 chunks of 16 bits, and then add up 4x4 products.
|
||||
// We can skip products that would overflow.
|
||||
|
||||
var a48 = this.high_ >>> 16;
|
||||
var a32 = this.high_ & 0xffff;
|
||||
var a16 = this.low_ >>> 16;
|
||||
var a00 = this.low_ & 0xffff;
|
||||
|
||||
var b48 = other.high_ >>> 16;
|
||||
var b32 = other.high_ & 0xffff;
|
||||
var b16 = other.low_ >>> 16;
|
||||
var b00 = other.low_ & 0xffff;
|
||||
|
||||
var c48 = 0,
|
||||
c32 = 0,
|
||||
c16 = 0,
|
||||
c00 = 0;
|
||||
c00 += a00 * b00;
|
||||
c16 += c00 >>> 16;
|
||||
c00 &= 0xffff;
|
||||
c16 += a16 * b00;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c16 += a00 * b16;
|
||||
c32 += c16 >>> 16;
|
||||
c16 &= 0xffff;
|
||||
c32 += a32 * b00;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c32 += a16 * b16;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c32 += a00 * b32;
|
||||
c48 += c32 >>> 16;
|
||||
c32 &= 0xffff;
|
||||
c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
|
||||
c48 &= 0xffff;
|
||||
return Timestamp.fromBits((c16 << 16) | c00, (c48 << 16) | c32);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Timestamp divided by the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp by which to divide.
|
||||
* @return {Timestamp} this Timestamp divided by the given one.
|
||||
*/
|
||||
Timestamp.prototype.div = function(other) {
|
||||
if (other.isZero()) {
|
||||
throw Error('division by zero');
|
||||
} else if (this.isZero()) {
|
||||
return Timestamp.ZERO;
|
||||
}
|
||||
|
||||
if (this.equals(Timestamp.MIN_VALUE)) {
|
||||
if (other.equals(Timestamp.ONE) || other.equals(Timestamp.NEG_ONE)) {
|
||||
return Timestamp.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
|
||||
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
||||
return Timestamp.ONE;
|
||||
} else {
|
||||
// At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.
|
||||
var halfThis = this.shiftRight(1);
|
||||
var approx = halfThis.div(other).shiftLeft(1);
|
||||
if (approx.equals(Timestamp.ZERO)) {
|
||||
return other.isNegative() ? Timestamp.ONE : Timestamp.NEG_ONE;
|
||||
} else {
|
||||
var rem = this.subtract(other.multiply(approx));
|
||||
var result = approx.add(rem.div(other));
|
||||
return result;
|
||||
}
|
||||
}
|
||||
} else if (other.equals(Timestamp.MIN_VALUE)) {
|
||||
return Timestamp.ZERO;
|
||||
}
|
||||
|
||||
if (this.isNegative()) {
|
||||
if (other.isNegative()) {
|
||||
return this.negate().div(other.negate());
|
||||
} else {
|
||||
return this.negate()
|
||||
.div(other)
|
||||
.negate();
|
||||
}
|
||||
} else if (other.isNegative()) {
|
||||
return this.div(other.negate()).negate();
|
||||
}
|
||||
|
||||
// Repeat the following until the remainder is less than other: find a
|
||||
// floating-point that approximates remainder / other *from below*, add this
|
||||
// into the result, and subtract it from the remainder. It is critical that
|
||||
// the approximate value is less than or equal to the real value so that the
|
||||
// remainder never becomes negative.
|
||||
var res = Timestamp.ZERO;
|
||||
rem = this;
|
||||
while (rem.greaterThanOrEqual(other)) {
|
||||
// Approximate the result of division. This may be a little greater or
|
||||
// smaller than the actual value.
|
||||
approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
|
||||
|
||||
// We will tweak the approximate result by changing it in the 48-th digit or
|
||||
// the smallest non-fractional digit, whichever is larger.
|
||||
var log2 = Math.ceil(Math.log(approx) / Math.LN2);
|
||||
var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
|
||||
|
||||
// Decrease the approximation until it is smaller than the remainder. Note
|
||||
// that if it is too large, the product overflows and is negative.
|
||||
var approxRes = Timestamp.fromNumber(approx);
|
||||
var approxRem = approxRes.multiply(other);
|
||||
while (approxRem.isNegative() || approxRem.greaterThan(rem)) {
|
||||
approx -= delta;
|
||||
approxRes = Timestamp.fromNumber(approx);
|
||||
approxRem = approxRes.multiply(other);
|
||||
}
|
||||
|
||||
// We know the answer can't be zero... and actually, zero would cause
|
||||
// infinite recursion since we would make no progress.
|
||||
if (approxRes.isZero()) {
|
||||
approxRes = Timestamp.ONE;
|
||||
}
|
||||
|
||||
res = res.add(approxRes);
|
||||
rem = rem.subtract(approxRem);
|
||||
}
|
||||
return res;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Timestamp modulo the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other Timestamp by which to mod.
|
||||
* @return {Timestamp} this Timestamp modulo the given one.
|
||||
*/
|
||||
Timestamp.prototype.modulo = function(other) {
|
||||
return this.subtract(this.div(other).multiply(other));
|
||||
};
|
||||
|
||||
/**
|
||||
* The bitwise-NOT of this value.
|
||||
*
|
||||
* @method
|
||||
* @return {Timestamp} the bitwise-NOT of this value.
|
||||
*/
|
||||
Timestamp.prototype.not = function() {
|
||||
return Timestamp.fromBits(~this.low_, ~this.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-AND of this Timestamp and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other the Timestamp with which to AND.
|
||||
* @return {Timestamp} the bitwise-AND of this and the other.
|
||||
*/
|
||||
Timestamp.prototype.and = function(other) {
|
||||
return Timestamp.fromBits(this.low_ & other.low_, this.high_ & other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-OR of this Timestamp and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other the Timestamp with which to OR.
|
||||
* @return {Timestamp} the bitwise-OR of this and the other.
|
||||
*/
|
||||
Timestamp.prototype.or = function(other) {
|
||||
return Timestamp.fromBits(this.low_ | other.low_, this.high_ | other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns the bitwise-XOR of this Timestamp and the given one.
|
||||
*
|
||||
* @method
|
||||
* @param {Timestamp} other the Timestamp with which to XOR.
|
||||
* @return {Timestamp} the bitwise-XOR of this and the other.
|
||||
*/
|
||||
Timestamp.prototype.xor = function(other) {
|
||||
return Timestamp.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Timestamp with bits shifted to the left by the given amount.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Timestamp} this shifted to the left by the given amount.
|
||||
*/
|
||||
Timestamp.prototype.shiftLeft = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var low = this.low_;
|
||||
if (numBits < 32) {
|
||||
var high = this.high_;
|
||||
return Timestamp.fromBits(low << numBits, (high << numBits) | (low >>> (32 - numBits)));
|
||||
} else {
|
||||
return Timestamp.fromBits(0, low << (numBits - 32));
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Timestamp with bits shifted to the right by the given amount.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Timestamp} this shifted to the right by the given amount.
|
||||
*/
|
||||
Timestamp.prototype.shiftRight = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var high = this.high_;
|
||||
if (numBits < 32) {
|
||||
var low = this.low_;
|
||||
return Timestamp.fromBits((low >>> numBits) | (high << (32 - numBits)), high >> numBits);
|
||||
} else {
|
||||
return Timestamp.fromBits(high >> (numBits - 32), high >= 0 ? 0 : -1);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns this Timestamp with bits shifted to the right by the given amount, with the new top bits matching the current sign bit.
|
||||
*
|
||||
* @method
|
||||
* @param {number} numBits the number of bits by which to shift.
|
||||
* @return {Timestamp} this shifted to the right by the given amount, with zeros placed into the new leading bits.
|
||||
*/
|
||||
Timestamp.prototype.shiftRightUnsigned = function(numBits) {
|
||||
numBits &= 63;
|
||||
if (numBits === 0) {
|
||||
return this;
|
||||
} else {
|
||||
var high = this.high_;
|
||||
if (numBits < 32) {
|
||||
var low = this.low_;
|
||||
return Timestamp.fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits);
|
||||
} else if (numBits === 32) {
|
||||
return Timestamp.fromBits(high, 0);
|
||||
} else {
|
||||
return Timestamp.fromBits(high >>> (numBits - 32), 0);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Timestamp representing the given (32-bit) integer value.
|
||||
*
|
||||
* @method
|
||||
* @param {number} value the 32-bit integer in question.
|
||||
* @return {Timestamp} the corresponding Timestamp value.
|
||||
*/
|
||||
Timestamp.fromInt = function(value) {
|
||||
if (-128 <= value && value < 128) {
|
||||
var cachedObj = Timestamp.INT_CACHE_[value];
|
||||
if (cachedObj) {
|
||||
return cachedObj;
|
||||
}
|
||||
}
|
||||
|
||||
var obj = new Timestamp(value | 0, value < 0 ? -1 : 0);
|
||||
if (-128 <= value && value < 128) {
|
||||
Timestamp.INT_CACHE_[value] = obj;
|
||||
}
|
||||
return obj;
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Timestamp representing the given value, provided that it is a finite number. Otherwise, zero is returned.
|
||||
*
|
||||
* @method
|
||||
* @param {number} value the number in question.
|
||||
* @return {Timestamp} the corresponding Timestamp value.
|
||||
*/
|
||||
Timestamp.fromNumber = function(value) {
|
||||
if (isNaN(value) || !isFinite(value)) {
|
||||
return Timestamp.ZERO;
|
||||
} else if (value <= -Timestamp.TWO_PWR_63_DBL_) {
|
||||
return Timestamp.MIN_VALUE;
|
||||
} else if (value + 1 >= Timestamp.TWO_PWR_63_DBL_) {
|
||||
return Timestamp.MAX_VALUE;
|
||||
} else if (value < 0) {
|
||||
return Timestamp.fromNumber(-value).negate();
|
||||
} else {
|
||||
return new Timestamp(
|
||||
(value % Timestamp.TWO_PWR_32_DBL_) | 0,
|
||||
(value / Timestamp.TWO_PWR_32_DBL_) | 0
|
||||
);
|
||||
}
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Timestamp representing the 64-bit integer that comes by concatenating the given high and low bits. Each is assumed to use 32 bits.
|
||||
*
|
||||
* @method
|
||||
* @param {number} lowBits the low 32-bits.
|
||||
* @param {number} highBits the high 32-bits.
|
||||
* @return {Timestamp} the corresponding Timestamp value.
|
||||
*/
|
||||
Timestamp.fromBits = function(lowBits, highBits) {
|
||||
return new Timestamp(lowBits, highBits);
|
||||
};
|
||||
|
||||
/**
|
||||
* Returns a Timestamp representation of the given string, written using the given radix.
|
||||
*
|
||||
* @method
|
||||
* @param {string} str the textual representation of the Timestamp.
|
||||
* @param {number} opt_radix the radix in which the text is written.
|
||||
* @return {Timestamp} the corresponding Timestamp value.
|
||||
*/
|
||||
Timestamp.fromString = function(str, opt_radix) {
|
||||
if (str.length === 0) {
|
||||
throw Error('number format error: empty string');
|
||||
}
|
||||
|
||||
var radix = opt_radix || 10;
|
||||
if (radix < 2 || 36 < radix) {
|
||||
throw Error('radix out of range: ' + radix);
|
||||
}
|
||||
|
||||
if (str.charAt(0) === '-') {
|
||||
return Timestamp.fromString(str.substring(1), radix).negate();
|
||||
} else if (str.indexOf('-') >= 0) {
|
||||
throw Error('number format error: interior "-" character: ' + str);
|
||||
}
|
||||
|
||||
// Do several (8) digits each time through the loop, so as to
|
||||
// minimize the calls to the very expensive emulated div.
|
||||
var radixToPower = Timestamp.fromNumber(Math.pow(radix, 8));
|
||||
|
||||
var result = Timestamp.ZERO;
|
||||
for (var i = 0; i < str.length; i += 8) {
|
||||
var size = Math.min(8, str.length - i);
|
||||
var value = parseInt(str.substring(i, i + size), radix);
|
||||
if (size < 8) {
|
||||
var power = Timestamp.fromNumber(Math.pow(radix, size));
|
||||
result = result.multiply(power).add(Timestamp.fromNumber(value));
|
||||
} else {
|
||||
result = result.multiply(radixToPower);
|
||||
result = result.add(Timestamp.fromNumber(value));
|
||||
}
|
||||
}
|
||||
return result;
|
||||
};
|
||||
|
||||
// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the
|
||||
// from* methods on which they depend.
|
||||
|
||||
/**
|
||||
* A cache of the Timestamp representations of small integer values.
|
||||
* @type {Object}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.INT_CACHE_ = {};
|
||||
|
||||
// NOTE: the compiler should inline these constant values below and then remove
|
||||
// these variables, so there should be no runtime penalty for these.
|
||||
|
||||
/**
|
||||
* Number used repeated below in calculations. This must appear before the
|
||||
* first call to any from* function below.
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_16_DBL_ = 1 << 16;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_24_DBL_ = 1 << 24;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_32_DBL_ = Timestamp.TWO_PWR_16_DBL_ * Timestamp.TWO_PWR_16_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_31_DBL_ = Timestamp.TWO_PWR_32_DBL_ / 2;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_48_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_16_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_64_DBL_ = Timestamp.TWO_PWR_32_DBL_ * Timestamp.TWO_PWR_32_DBL_;
|
||||
|
||||
/**
|
||||
* @type {number}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_63_DBL_ = Timestamp.TWO_PWR_64_DBL_ / 2;
|
||||
|
||||
/** @type {Timestamp} */
|
||||
Timestamp.ZERO = Timestamp.fromInt(0);
|
||||
|
||||
/** @type {Timestamp} */
|
||||
Timestamp.ONE = Timestamp.fromInt(1);
|
||||
|
||||
/** @type {Timestamp} */
|
||||
Timestamp.NEG_ONE = Timestamp.fromInt(-1);
|
||||
|
||||
/** @type {Timestamp} */
|
||||
Timestamp.MAX_VALUE = Timestamp.fromBits(0xffffffff | 0, 0x7fffffff | 0);
|
||||
|
||||
/** @type {Timestamp} */
|
||||
Timestamp.MIN_VALUE = Timestamp.fromBits(0, 0x80000000 | 0);
|
||||
|
||||
/**
|
||||
* @type {Timestamp}
|
||||
* @ignore
|
||||
*/
|
||||
Timestamp.TWO_PWR_24_ = Timestamp.fromInt(1 << 24);
|
||||
|
||||
/**
|
||||
* Expose.
|
||||
*/
|
||||
module.exports = Timestamp;
|
||||
module.exports.Timestamp = Timestamp;
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
{
|
||||
"_from": "bson@^1.1.0",
|
||||
"_id": "bson@1.1.0",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-9Aeai9TacfNtWXOYarkFJRW2CWo+dRon+fuLZYJmvLV3+MiUp0bEI6IAZfXEIg7/Pl/7IWlLaDnhzTsD81etQA==",
|
||||
"_location": "/mongodb-core/bson",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "bson@^1.1.0",
|
||||
"name": "bson",
|
||||
"escapedName": "bson",
|
||||
"rawSpec": "^1.1.0",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^1.1.0"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/mongodb-core"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/bson/-/bson-1.1.0.tgz",
|
||||
"_shasum": "bee57d1fb6a87713471af4e32bcae36de814b5b0",
|
||||
"_spec": "bson@^1.1.0",
|
||||
"_where": "C:\\Users\\Luis\\source\\repos\\Modules\\Users\\server\\node_modules\\mongodb-core",
|
||||
"author": {
|
||||
"name": "Christian Amor Kvalheim",
|
||||
"email": "christkv@gmail.com"
|
||||
},
|
||||
"browser": "lib/bson/bson.js",
|
||||
"bugs": {
|
||||
"url": "https://github.com/mongodb/js-bson/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"config": {
|
||||
"native": false
|
||||
},
|
||||
"contributors": [],
|
||||
"deprecated": false,
|
||||
"description": "A bson parser for node.js and the browser",
|
||||
"devDependencies": {
|
||||
"babel-core": "^6.14.0",
|
||||
"babel-loader": "^6.2.5",
|
||||
"babel-polyfill": "^6.13.0",
|
||||
"babel-preset-es2015": "^6.14.0",
|
||||
"babel-preset-stage-0": "^6.5.0",
|
||||
"babel-register": "^6.14.0",
|
||||
"benchmark": "1.0.0",
|
||||
"colors": "1.1.0",
|
||||
"conventional-changelog-cli": "^1.3.5",
|
||||
"nodeunit": "0.9.0",
|
||||
"webpack": "^1.13.2",
|
||||
"webpack-polyfills-plugin": "0.0.9"
|
||||
},
|
||||
"directories": {
|
||||
"lib": "./lib/bson"
|
||||
},
|
||||
"engines": {
|
||||
"node": ">=0.6.19"
|
||||
},
|
||||
"files": [
|
||||
"lib",
|
||||
"index.js",
|
||||
"browser_build",
|
||||
"bower.json"
|
||||
],
|
||||
"homepage": "https://github.com/mongodb/js-bson#readme",
|
||||
"keywords": [
|
||||
"mongodb",
|
||||
"bson",
|
||||
"parser"
|
||||
],
|
||||
"license": "Apache-2.0",
|
||||
"main": "./index",
|
||||
"name": "bson",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git+https://github.com/mongodb/js-bson.git"
|
||||
},
|
||||
"scripts": {
|
||||
"build": "webpack --config ./webpack.dist.config.js",
|
||||
"changelog": "conventional-changelog -p angular -i HISTORY.md -s",
|
||||
"format": "prettier --print-width 100 --tab-width 2 --single-quote --write 'test/**/*.js' 'lib/**/*.js'",
|
||||
"lint": "eslint lib test",
|
||||
"test": "nodeunit ./test/node"
|
||||
},
|
||||
"version": "1.1.0"
|
||||
}
|
||||
+21
@@ -0,0 +1,21 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Feross Aboukhadijeh
|
||||
|
||||
Permission is hereby granted, free of charge, to any person obtaining a copy
|
||||
of this software and associated documentation files (the "Software"), to deal
|
||||
in the Software without restriction, including without limitation the rights
|
||||
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||||
copies of the Software, and to permit persons to whom the Software is
|
||||
furnished to do so, subject to the following conditions:
|
||||
|
||||
The above copyright notice and this permission notice shall be included in
|
||||
all copies or substantial portions of the Software.
|
||||
|
||||
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||||
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||||
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||||
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||||
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||||
THE SOFTWARE.
|
||||
+584
@@ -0,0 +1,584 @@
|
||||
# safe-buffer [![travis][travis-image]][travis-url] [![npm][npm-image]][npm-url] [![downloads][downloads-image]][downloads-url] [![javascript style guide][standard-image]][standard-url]
|
||||
|
||||
[travis-image]: https://img.shields.io/travis/feross/safe-buffer/master.svg
|
||||
[travis-url]: https://travis-ci.org/feross/safe-buffer
|
||||
[npm-image]: https://img.shields.io/npm/v/safe-buffer.svg
|
||||
[npm-url]: https://npmjs.org/package/safe-buffer
|
||||
[downloads-image]: https://img.shields.io/npm/dm/safe-buffer.svg
|
||||
[downloads-url]: https://npmjs.org/package/safe-buffer
|
||||
[standard-image]: https://img.shields.io/badge/code_style-standard-brightgreen.svg
|
||||
[standard-url]: https://standardjs.com
|
||||
|
||||
#### Safer Node.js Buffer API
|
||||
|
||||
**Use the new Node.js Buffer APIs (`Buffer.from`, `Buffer.alloc`,
|
||||
`Buffer.allocUnsafe`, `Buffer.allocUnsafeSlow`) in all versions of Node.js.**
|
||||
|
||||
**Uses the built-in implementation when available.**
|
||||
|
||||
## install
|
||||
|
||||
```
|
||||
npm install safe-buffer
|
||||
```
|
||||
|
||||
## usage
|
||||
|
||||
The goal of this package is to provide a safe replacement for the node.js `Buffer`.
|
||||
|
||||
It's a drop-in replacement for `Buffer`. You can use it by adding one `require` line to
|
||||
the top of your node.js modules:
|
||||
|
||||
```js
|
||||
var Buffer = require('safe-buffer').Buffer
|
||||
|
||||
// Existing buffer code will continue to work without issues:
|
||||
|
||||
new Buffer('hey', 'utf8')
|
||||
new Buffer([1, 2, 3], 'utf8')
|
||||
new Buffer(obj)
|
||||
new Buffer(16) // create an uninitialized buffer (potentially unsafe)
|
||||
|
||||
// But you can use these new explicit APIs to make clear what you want:
|
||||
|
||||
Buffer.from('hey', 'utf8') // convert from many types to a Buffer
|
||||
Buffer.alloc(16) // create a zero-filled buffer (safe)
|
||||
Buffer.allocUnsafe(16) // create an uninitialized buffer (potentially unsafe)
|
||||
```
|
||||
|
||||
## api
|
||||
|
||||
### Class Method: Buffer.from(array)
|
||||
<!-- YAML
|
||||
added: v3.0.0
|
||||
-->
|
||||
|
||||
* `array` {Array}
|
||||
|
||||
Allocates a new `Buffer` using an `array` of octets.
|
||||
|
||||
```js
|
||||
const buf = Buffer.from([0x62,0x75,0x66,0x66,0x65,0x72]);
|
||||
// creates a new Buffer containing ASCII bytes
|
||||
// ['b','u','f','f','e','r']
|
||||
```
|
||||
|
||||
A `TypeError` will be thrown if `array` is not an `Array`.
|
||||
|
||||
### Class Method: Buffer.from(arrayBuffer[, byteOffset[, length]])
|
||||
<!-- YAML
|
||||
added: v5.10.0
|
||||
-->
|
||||
|
||||
* `arrayBuffer` {ArrayBuffer} The `.buffer` property of a `TypedArray` or
|
||||
a `new ArrayBuffer()`
|
||||
* `byteOffset` {Number} Default: `0`
|
||||
* `length` {Number} Default: `arrayBuffer.length - byteOffset`
|
||||
|
||||
When passed a reference to the `.buffer` property of a `TypedArray` instance,
|
||||
the newly created `Buffer` will share the same allocated memory as the
|
||||
TypedArray.
|
||||
|
||||
```js
|
||||
const arr = new Uint16Array(2);
|
||||
arr[0] = 5000;
|
||||
arr[1] = 4000;
|
||||
|
||||
const buf = Buffer.from(arr.buffer); // shares the memory with arr;
|
||||
|
||||
console.log(buf);
|
||||
// Prints: <Buffer 88 13 a0 0f>
|
||||
|
||||
// changing the TypedArray changes the Buffer also
|
||||
arr[1] = 6000;
|
||||
|
||||
console.log(buf);
|
||||
// Prints: <Buffer 88 13 70 17>
|
||||
```
|
||||
|
||||
The optional `byteOffset` and `length` arguments specify a memory range within
|
||||
the `arrayBuffer` that will be shared by the `Buffer`.
|
||||
|
||||
```js
|
||||
const ab = new ArrayBuffer(10);
|
||||
const buf = Buffer.from(ab, 0, 2);
|
||||
console.log(buf.length);
|
||||
// Prints: 2
|
||||
```
|
||||
|
||||
A `TypeError` will be thrown if `arrayBuffer` is not an `ArrayBuffer`.
|
||||
|
||||
### Class Method: Buffer.from(buffer)
|
||||
<!-- YAML
|
||||
added: v3.0.0
|
||||
-->
|
||||
|
||||
* `buffer` {Buffer}
|
||||
|
||||
Copies the passed `buffer` data onto a new `Buffer` instance.
|
||||
|
||||
```js
|
||||
const buf1 = Buffer.from('buffer');
|
||||
const buf2 = Buffer.from(buf1);
|
||||
|
||||
buf1[0] = 0x61;
|
||||
console.log(buf1.toString());
|
||||
// 'auffer'
|
||||
console.log(buf2.toString());
|
||||
// 'buffer' (copy is not changed)
|
||||
```
|
||||
|
||||
A `TypeError` will be thrown if `buffer` is not a `Buffer`.
|
||||
|
||||
### Class Method: Buffer.from(str[, encoding])
|
||||
<!-- YAML
|
||||
added: v5.10.0
|
||||
-->
|
||||
|
||||
* `str` {String} String to encode.
|
||||
* `encoding` {String} Encoding to use, Default: `'utf8'`
|
||||
|
||||
Creates a new `Buffer` containing the given JavaScript string `str`. If
|
||||
provided, the `encoding` parameter identifies the character encoding.
|
||||
If not provided, `encoding` defaults to `'utf8'`.
|
||||
|
||||
```js
|
||||
const buf1 = Buffer.from('this is a tést');
|
||||
console.log(buf1.toString());
|
||||
// prints: this is a tést
|
||||
console.log(buf1.toString('ascii'));
|
||||
// prints: this is a tC)st
|
||||
|
||||
const buf2 = Buffer.from('7468697320697320612074c3a97374', 'hex');
|
||||
console.log(buf2.toString());
|
||||
// prints: this is a tést
|
||||
```
|
||||
|
||||
A `TypeError` will be thrown if `str` is not a string.
|
||||
|
||||
### Class Method: Buffer.alloc(size[, fill[, encoding]])
|
||||
<!-- YAML
|
||||
added: v5.10.0
|
||||
-->
|
||||
|
||||
* `size` {Number}
|
||||
* `fill` {Value} Default: `undefined`
|
||||
* `encoding` {String} Default: `utf8`
|
||||
|
||||
Allocates a new `Buffer` of `size` bytes. If `fill` is `undefined`, the
|
||||
`Buffer` will be *zero-filled*.
|
||||
|
||||
```js
|
||||
const buf = Buffer.alloc(5);
|
||||
console.log(buf);
|
||||
// <Buffer 00 00 00 00 00>
|
||||
```
|
||||
|
||||
The `size` must be less than or equal to the value of
|
||||
`require('buffer').kMaxLength` (on 64-bit architectures, `kMaxLength` is
|
||||
`(2^31)-1`). Otherwise, a [`RangeError`][] is thrown. A zero-length Buffer will
|
||||
be created if a `size` less than or equal to 0 is specified.
|
||||
|
||||
If `fill` is specified, the allocated `Buffer` will be initialized by calling
|
||||
`buf.fill(fill)`. See [`buf.fill()`][] for more information.
|
||||
|
||||
```js
|
||||
const buf = Buffer.alloc(5, 'a');
|
||||
console.log(buf);
|
||||
// <Buffer 61 61 61 61 61>
|
||||
```
|
||||
|
||||
If both `fill` and `encoding` are specified, the allocated `Buffer` will be
|
||||
initialized by calling `buf.fill(fill, encoding)`. For example:
|
||||
|
||||
```js
|
||||
const buf = Buffer.alloc(11, 'aGVsbG8gd29ybGQ=', 'base64');
|
||||
console.log(buf);
|
||||
// <Buffer 68 65 6c 6c 6f 20 77 6f 72 6c 64>
|
||||
```
|
||||
|
||||
Calling `Buffer.alloc(size)` can be significantly slower than the alternative
|
||||
`Buffer.allocUnsafe(size)` but ensures that the newly created `Buffer` instance
|
||||
contents will *never contain sensitive data*.
|
||||
|
||||
A `TypeError` will be thrown if `size` is not a number.
|
||||
|
||||
### Class Method: Buffer.allocUnsafe(size)
|
||||
<!-- YAML
|
||||
added: v5.10.0
|
||||
-->
|
||||
|
||||
* `size` {Number}
|
||||
|
||||
Allocates a new *non-zero-filled* `Buffer` of `size` bytes. The `size` must
|
||||
be less than or equal to the value of `require('buffer').kMaxLength` (on 64-bit
|
||||
architectures, `kMaxLength` is `(2^31)-1`). Otherwise, a [`RangeError`][] is
|
||||
thrown. A zero-length Buffer will be created if a `size` less than or equal to
|
||||
0 is specified.
|
||||
|
||||
The underlying memory for `Buffer` instances created in this way is *not
|
||||
initialized*. The contents of the newly created `Buffer` are unknown and
|
||||
*may contain sensitive data*. Use [`buf.fill(0)`][] to initialize such
|
||||
`Buffer` instances to zeroes.
|
||||
|
||||
```js
|
||||
const buf = Buffer.allocUnsafe(5);
|
||||
console.log(buf);
|
||||
// <Buffer 78 e0 82 02 01>
|
||||
// (octets will be different, every time)
|
||||
buf.fill(0);
|
||||
console.log(buf);
|
||||
// <Buffer 00 00 00 00 00>
|
||||
```
|
||||
|
||||
A `TypeError` will be thrown if `size` is not a number.
|
||||
|
||||
Note that the `Buffer` module pre-allocates an internal `Buffer` instance of
|
||||
size `Buffer.poolSize` that is used as a pool for the fast allocation of new
|
||||
`Buffer` instances created using `Buffer.allocUnsafe(size)` (and the deprecated
|
||||
`new Buffer(size)` constructor) only when `size` is less than or equal to
|
||||
`Buffer.poolSize >> 1` (floor of `Buffer.poolSize` divided by two). The default
|
||||
value of `Buffer.poolSize` is `8192` but can be modified.
|
||||
|
||||
Use of this pre-allocated internal memory pool is a key difference between
|
||||
calling `Buffer.alloc(size, fill)` vs. `Buffer.allocUnsafe(size).fill(fill)`.
|
||||
Specifically, `Buffer.alloc(size, fill)` will *never* use the internal Buffer
|
||||
pool, while `Buffer.allocUnsafe(size).fill(fill)` *will* use the internal
|
||||
Buffer pool if `size` is less than or equal to half `Buffer.poolSize`. The
|
||||
difference is subtle but can be important when an application requires the
|
||||
additional performance that `Buffer.allocUnsafe(size)` provides.
|
||||
|
||||
### Class Method: Buffer.allocUnsafeSlow(size)
|
||||
<!-- YAML
|
||||
added: v5.10.0
|
||||
-->
|
||||
|
||||
* `size` {Number}
|
||||
|
||||
Allocates a new *non-zero-filled* and non-pooled `Buffer` of `size` bytes. The
|
||||
`size` must be less than or equal to the value of
|
||||
`require('buffer').kMaxLength` (on 64-bit architectures, `kMaxLength` is
|
||||
`(2^31)-1`). Otherwise, a [`RangeError`][] is thrown. A zero-length Buffer will
|
||||
be created if a `size` less than or equal to 0 is specified.
|
||||
|
||||
The underlying memory for `Buffer` instances created in this way is *not
|
||||
initialized*. The contents of the newly created `Buffer` are unknown and
|
||||
*may contain sensitive data*. Use [`buf.fill(0)`][] to initialize such
|
||||
`Buffer` instances to zeroes.
|
||||
|
||||
When using `Buffer.allocUnsafe()` to allocate new `Buffer` instances,
|
||||
allocations under 4KB are, by default, sliced from a single pre-allocated
|
||||
`Buffer`. This allows applications to avoid the garbage collection overhead of
|
||||
creating many individually allocated Buffers. This approach improves both
|
||||
performance and memory usage by eliminating the need to track and cleanup as
|
||||
many `Persistent` objects.
|
||||
|
||||
However, in the case where a developer may need to retain a small chunk of
|
||||
memory from a pool for an indeterminate amount of time, it may be appropriate
|
||||
to create an un-pooled Buffer instance using `Buffer.allocUnsafeSlow()` then
|
||||
copy out the relevant bits.
|
||||
|
||||
```js
|
||||
// need to keep around a few small chunks of memory
|
||||
const store = [];
|
||||
|
||||
socket.on('readable', () => {
|
||||
const data = socket.read();
|
||||
// allocate for retained data
|
||||
const sb = Buffer.allocUnsafeSlow(10);
|
||||
// copy the data into the new allocation
|
||||
data.copy(sb, 0, 0, 10);
|
||||
store.push(sb);
|
||||
});
|
||||
```
|
||||
|
||||
Use of `Buffer.allocUnsafeSlow()` should be used only as a last resort *after*
|
||||
a developer has observed undue memory retention in their applications.
|
||||
|
||||
A `TypeError` will be thrown if `size` is not a number.
|
||||
|
||||
### All the Rest
|
||||
|
||||
The rest of the `Buffer` API is exactly the same as in node.js.
|
||||
[See the docs](https://nodejs.org/api/buffer.html).
|
||||
|
||||
|
||||
## Related links
|
||||
|
||||
- [Node.js issue: Buffer(number) is unsafe](https://github.com/nodejs/node/issues/4660)
|
||||
- [Node.js Enhancement Proposal: Buffer.from/Buffer.alloc/Buffer.zalloc/Buffer() soft-deprecate](https://github.com/nodejs/node-eps/pull/4)
|
||||
|
||||
## Why is `Buffer` unsafe?
|
||||
|
||||
Today, the node.js `Buffer` constructor is overloaded to handle many different argument
|
||||
types like `String`, `Array`, `Object`, `TypedArrayView` (`Uint8Array`, etc.),
|
||||
`ArrayBuffer`, and also `Number`.
|
||||
|
||||
The API is optimized for convenience: you can throw any type at it, and it will try to do
|
||||
what you want.
|
||||
|
||||
Because the Buffer constructor is so powerful, you often see code like this:
|
||||
|
||||
```js
|
||||
// Convert UTF-8 strings to hex
|
||||
function toHex (str) {
|
||||
return new Buffer(str).toString('hex')
|
||||
}
|
||||
```
|
||||
|
||||
***But what happens if `toHex` is called with a `Number` argument?***
|
||||
|
||||
### Remote Memory Disclosure
|
||||
|
||||
If an attacker can make your program call the `Buffer` constructor with a `Number`
|
||||
argument, then they can make it allocate uninitialized memory from the node.js process.
|
||||
This could potentially disclose TLS private keys, user data, or database passwords.
|
||||
|
||||
When the `Buffer` constructor is passed a `Number` argument, it returns an
|
||||
**UNINITIALIZED** block of memory of the specified `size`. When you create a `Buffer` like
|
||||
this, you **MUST** overwrite the contents before returning it to the user.
|
||||
|
||||
From the [node.js docs](https://nodejs.org/api/buffer.html#buffer_new_buffer_size):
|
||||
|
||||
> `new Buffer(size)`
|
||||
>
|
||||
> - `size` Number
|
||||
>
|
||||
> The underlying memory for `Buffer` instances created in this way is not initialized.
|
||||
> **The contents of a newly created `Buffer` are unknown and could contain sensitive
|
||||
> data.** Use `buf.fill(0)` to initialize a Buffer to zeroes.
|
||||
|
||||
(Emphasis our own.)
|
||||
|
||||
Whenever the programmer intended to create an uninitialized `Buffer` you often see code
|
||||
like this:
|
||||
|
||||
```js
|
||||
var buf = new Buffer(16)
|
||||
|
||||
// Immediately overwrite the uninitialized buffer with data from another buffer
|
||||
for (var i = 0; i < buf.length; i++) {
|
||||
buf[i] = otherBuf[i]
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### Would this ever be a problem in real code?
|
||||
|
||||
Yes. It's surprisingly common to forget to check the type of your variables in a
|
||||
dynamically-typed language like JavaScript.
|
||||
|
||||
Usually the consequences of assuming the wrong type is that your program crashes with an
|
||||
uncaught exception. But the failure mode for forgetting to check the type of arguments to
|
||||
the `Buffer` constructor is more catastrophic.
|
||||
|
||||
Here's an example of a vulnerable service that takes a JSON payload and converts it to
|
||||
hex:
|
||||
|
||||
```js
|
||||
// Take a JSON payload {str: "some string"} and convert it to hex
|
||||
var server = http.createServer(function (req, res) {
|
||||
var data = ''
|
||||
req.setEncoding('utf8')
|
||||
req.on('data', function (chunk) {
|
||||
data += chunk
|
||||
})
|
||||
req.on('end', function () {
|
||||
var body = JSON.parse(data)
|
||||
res.end(new Buffer(body.str).toString('hex'))
|
||||
})
|
||||
})
|
||||
|
||||
server.listen(8080)
|
||||
```
|
||||
|
||||
In this example, an http client just has to send:
|
||||
|
||||
```json
|
||||
{
|
||||
"str": 1000
|
||||
}
|
||||
```
|
||||
|
||||
and it will get back 1,000 bytes of uninitialized memory from the server.
|
||||
|
||||
This is a very serious bug. It's similar in severity to the
|
||||
[the Heartbleed bug](http://heartbleed.com/) that allowed disclosure of OpenSSL process
|
||||
memory by remote attackers.
|
||||
|
||||
|
||||
### Which real-world packages were vulnerable?
|
||||
|
||||
#### [`bittorrent-dht`](https://www.npmjs.com/package/bittorrent-dht)
|
||||
|
||||
[Mathias Buus](https://github.com/mafintosh) and I
|
||||
([Feross Aboukhadijeh](http://feross.org/)) found this issue in one of our own packages,
|
||||
[`bittorrent-dht`](https://www.npmjs.com/package/bittorrent-dht). The bug would allow
|
||||
anyone on the internet to send a series of messages to a user of `bittorrent-dht` and get
|
||||
them to reveal 20 bytes at a time of uninitialized memory from the node.js process.
|
||||
|
||||
Here's
|
||||
[the commit](https://github.com/feross/bittorrent-dht/commit/6c7da04025d5633699800a99ec3fbadf70ad35b8)
|
||||
that fixed it. We released a new fixed version, created a
|
||||
[Node Security Project disclosure](https://nodesecurity.io/advisories/68), and deprecated all
|
||||
vulnerable versions on npm so users will get a warning to upgrade to a newer version.
|
||||
|
||||
#### [`ws`](https://www.npmjs.com/package/ws)
|
||||
|
||||
That got us wondering if there were other vulnerable packages. Sure enough, within a short
|
||||
period of time, we found the same issue in [`ws`](https://www.npmjs.com/package/ws), the
|
||||
most popular WebSocket implementation in node.js.
|
||||
|
||||
If certain APIs were called with `Number` parameters instead of `String` or `Buffer` as
|
||||
expected, then uninitialized server memory would be disclosed to the remote peer.
|
||||
|
||||
These were the vulnerable methods:
|
||||
|
||||
```js
|
||||
socket.send(number)
|
||||
socket.ping(number)
|
||||
socket.pong(number)
|
||||
```
|
||||
|
||||
Here's a vulnerable socket server with some echo functionality:
|
||||
|
||||
```js
|
||||
server.on('connection', function (socket) {
|
||||
socket.on('message', function (message) {
|
||||
message = JSON.parse(message)
|
||||
if (message.type === 'echo') {
|
||||
socket.send(message.data) // send back the user's message
|
||||
}
|
||||
})
|
||||
})
|
||||
```
|
||||
|
||||
`socket.send(number)` called on the server, will disclose server memory.
|
||||
|
||||
Here's [the release](https://github.com/websockets/ws/releases/tag/1.0.1) where the issue
|
||||
was fixed, with a more detailed explanation. Props to
|
||||
[Arnout Kazemier](https://github.com/3rd-Eden) for the quick fix. Here's the
|
||||
[Node Security Project disclosure](https://nodesecurity.io/advisories/67).
|
||||
|
||||
|
||||
### What's the solution?
|
||||
|
||||
It's important that node.js offers a fast way to get memory otherwise performance-critical
|
||||
applications would needlessly get a lot slower.
|
||||
|
||||
But we need a better way to *signal our intent* as programmers. **When we want
|
||||
uninitialized memory, we should request it explicitly.**
|
||||
|
||||
Sensitive functionality should not be packed into a developer-friendly API that loosely
|
||||
accepts many different types. This type of API encourages the lazy practice of passing
|
||||
variables in without checking the type very carefully.
|
||||
|
||||
#### A new API: `Buffer.allocUnsafe(number)`
|
||||
|
||||
The functionality of creating buffers with uninitialized memory should be part of another
|
||||
API. We propose `Buffer.allocUnsafe(number)`. This way, it's not part of an API that
|
||||
frequently gets user input of all sorts of different types passed into it.
|
||||
|
||||
```js
|
||||
var buf = Buffer.allocUnsafe(16) // careful, uninitialized memory!
|
||||
|
||||
// Immediately overwrite the uninitialized buffer with data from another buffer
|
||||
for (var i = 0; i < buf.length; i++) {
|
||||
buf[i] = otherBuf[i]
|
||||
}
|
||||
```
|
||||
|
||||
|
||||
### How do we fix node.js core?
|
||||
|
||||
We sent [a PR to node.js core](https://github.com/nodejs/node/pull/4514) (merged as
|
||||
`semver-major`) which defends against one case:
|
||||
|
||||
```js
|
||||
var str = 16
|
||||
new Buffer(str, 'utf8')
|
||||
```
|
||||
|
||||
In this situation, it's implied that the programmer intended the first argument to be a
|
||||
string, since they passed an encoding as a second argument. Today, node.js will allocate
|
||||
uninitialized memory in the case of `new Buffer(number, encoding)`, which is probably not
|
||||
what the programmer intended.
|
||||
|
||||
But this is only a partial solution, since if the programmer does `new Buffer(variable)`
|
||||
(without an `encoding` parameter) there's no way to know what they intended. If `variable`
|
||||
is sometimes a number, then uninitialized memory will sometimes be returned.
|
||||
|
||||
### What's the real long-term fix?
|
||||
|
||||
We could deprecate and remove `new Buffer(number)` and use `Buffer.allocUnsafe(number)` when
|
||||
we need uninitialized memory. But that would break 1000s of packages.
|
||||
|
||||
~~We believe the best solution is to:~~
|
||||
|
||||
~~1. Change `new Buffer(number)` to return safe, zeroed-out memory~~
|
||||
|
||||
~~2. Create a new API for creating uninitialized Buffers. We propose: `Buffer.allocUnsafe(number)`~~
|
||||
|
||||
#### Update
|
||||
|
||||
We now support adding three new APIs:
|
||||
|
||||
- `Buffer.from(value)` - convert from any type to a buffer
|
||||
- `Buffer.alloc(size)` - create a zero-filled buffer
|
||||
- `Buffer.allocUnsafe(size)` - create an uninitialized buffer with given size
|
||||
|
||||
This solves the core problem that affected `ws` and `bittorrent-dht` which is
|
||||
`Buffer(variable)` getting tricked into taking a number argument.
|
||||
|
||||
This way, existing code continues working and the impact on the npm ecosystem will be
|
||||
minimal. Over time, npm maintainers can migrate performance-critical code to use
|
||||
`Buffer.allocUnsafe(number)` instead of `new Buffer(number)`.
|
||||
|
||||
|
||||
### Conclusion
|
||||
|
||||
We think there's a serious design issue with the `Buffer` API as it exists today. It
|
||||
promotes insecure software by putting high-risk functionality into a convenient API
|
||||
with friendly "developer ergonomics".
|
||||
|
||||
This wasn't merely a theoretical exercise because we found the issue in some of the
|
||||
most popular npm packages.
|
||||
|
||||
Fortunately, there's an easy fix that can be applied today. Use `safe-buffer` in place of
|
||||
`buffer`.
|
||||
|
||||
```js
|
||||
var Buffer = require('safe-buffer').Buffer
|
||||
```
|
||||
|
||||
Eventually, we hope that node.js core can switch to this new, safer behavior. We believe
|
||||
the impact on the ecosystem would be minimal since it's not a breaking change.
|
||||
Well-maintained, popular packages would be updated to use `Buffer.alloc` quickly, while
|
||||
older, insecure packages would magically become safe from this attack vector.
|
||||
|
||||
|
||||
## links
|
||||
|
||||
- [Node.js PR: buffer: throw if both length and enc are passed](https://github.com/nodejs/node/pull/4514)
|
||||
- [Node Security Project disclosure for `ws`](https://nodesecurity.io/advisories/67)
|
||||
- [Node Security Project disclosure for`bittorrent-dht`](https://nodesecurity.io/advisories/68)
|
||||
|
||||
|
||||
## credit
|
||||
|
||||
The original issues in `bittorrent-dht`
|
||||
([disclosure](https://nodesecurity.io/advisories/68)) and
|
||||
`ws` ([disclosure](https://nodesecurity.io/advisories/67)) were discovered by
|
||||
[Mathias Buus](https://github.com/mafintosh) and
|
||||
[Feross Aboukhadijeh](http://feross.org/).
|
||||
|
||||
Thanks to [Adam Baldwin](https://github.com/evilpacket) for helping disclose these issues
|
||||
and for his work running the [Node Security Project](https://nodesecurity.io/).
|
||||
|
||||
Thanks to [John Hiesey](https://github.com/jhiesey) for proofreading this README and
|
||||
auditing the code.
|
||||
|
||||
|
||||
## license
|
||||
|
||||
MIT. Copyright (C) [Feross Aboukhadijeh](http://feross.org)
|
||||
+187
@@ -0,0 +1,187 @@
|
||||
declare module "safe-buffer" {
|
||||
export class Buffer {
|
||||
length: number
|
||||
write(string: string, offset?: number, length?: number, encoding?: string): number;
|
||||
toString(encoding?: string, start?: number, end?: number): string;
|
||||
toJSON(): { type: 'Buffer', data: any[] };
|
||||
equals(otherBuffer: Buffer): boolean;
|
||||
compare(otherBuffer: Buffer, targetStart?: number, targetEnd?: number, sourceStart?: number, sourceEnd?: number): number;
|
||||
copy(targetBuffer: Buffer, targetStart?: number, sourceStart?: number, sourceEnd?: number): number;
|
||||
slice(start?: number, end?: number): Buffer;
|
||||
writeUIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
writeUIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
writeIntLE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
writeIntBE(value: number, offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
readUIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
readUIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
readIntLE(offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
readIntBE(offset: number, byteLength: number, noAssert?: boolean): number;
|
||||
readUInt8(offset: number, noAssert?: boolean): number;
|
||||
readUInt16LE(offset: number, noAssert?: boolean): number;
|
||||
readUInt16BE(offset: number, noAssert?: boolean): number;
|
||||
readUInt32LE(offset: number, noAssert?: boolean): number;
|
||||
readUInt32BE(offset: number, noAssert?: boolean): number;
|
||||
readInt8(offset: number, noAssert?: boolean): number;
|
||||
readInt16LE(offset: number, noAssert?: boolean): number;
|
||||
readInt16BE(offset: number, noAssert?: boolean): number;
|
||||
readInt32LE(offset: number, noAssert?: boolean): number;
|
||||
readInt32BE(offset: number, noAssert?: boolean): number;
|
||||
readFloatLE(offset: number, noAssert?: boolean): number;
|
||||
readFloatBE(offset: number, noAssert?: boolean): number;
|
||||
readDoubleLE(offset: number, noAssert?: boolean): number;
|
||||
readDoubleBE(offset: number, noAssert?: boolean): number;
|
||||
swap16(): Buffer;
|
||||
swap32(): Buffer;
|
||||
swap64(): Buffer;
|
||||
writeUInt8(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeUInt16LE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeUInt16BE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeUInt32LE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeUInt32BE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeInt8(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeInt16LE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeInt16BE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeInt32LE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeInt32BE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeFloatLE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeFloatBE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeDoubleLE(value: number, offset: number, noAssert?: boolean): number;
|
||||
writeDoubleBE(value: number, offset: number, noAssert?: boolean): number;
|
||||
fill(value: any, offset?: number, end?: number): this;
|
||||
indexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
|
||||
lastIndexOf(value: string | number | Buffer, byteOffset?: number, encoding?: string): number;
|
||||
includes(value: string | number | Buffer, byteOffset?: number, encoding?: string): boolean;
|
||||
|
||||
/**
|
||||
* Allocates a new buffer containing the given {str}.
|
||||
*
|
||||
* @param str String to store in buffer.
|
||||
* @param encoding encoding to use, optional. Default is 'utf8'
|
||||
*/
|
||||
constructor (str: string, encoding?: string);
|
||||
/**
|
||||
* Allocates a new buffer of {size} octets.
|
||||
*
|
||||
* @param size count of octets to allocate.
|
||||
*/
|
||||
constructor (size: number);
|
||||
/**
|
||||
* Allocates a new buffer containing the given {array} of octets.
|
||||
*
|
||||
* @param array The octets to store.
|
||||
*/
|
||||
constructor (array: Uint8Array);
|
||||
/**
|
||||
* Produces a Buffer backed by the same allocated memory as
|
||||
* the given {ArrayBuffer}.
|
||||
*
|
||||
*
|
||||
* @param arrayBuffer The ArrayBuffer with which to share memory.
|
||||
*/
|
||||
constructor (arrayBuffer: ArrayBuffer);
|
||||
/**
|
||||
* Allocates a new buffer containing the given {array} of octets.
|
||||
*
|
||||
* @param array The octets to store.
|
||||
*/
|
||||
constructor (array: any[]);
|
||||
/**
|
||||
* Copies the passed {buffer} data onto a new {Buffer} instance.
|
||||
*
|
||||
* @param buffer The buffer to copy.
|
||||
*/
|
||||
constructor (buffer: Buffer);
|
||||
prototype: Buffer;
|
||||
/**
|
||||
* Allocates a new Buffer using an {array} of octets.
|
||||
*
|
||||
* @param array
|
||||
*/
|
||||
static from(array: any[]): Buffer;
|
||||
/**
|
||||
* When passed a reference to the .buffer property of a TypedArray instance,
|
||||
* the newly created Buffer will share the same allocated memory as the TypedArray.
|
||||
* The optional {byteOffset} and {length} arguments specify a memory range
|
||||
* within the {arrayBuffer} that will be shared by the Buffer.
|
||||
*
|
||||
* @param arrayBuffer The .buffer property of a TypedArray or a new ArrayBuffer()
|
||||
* @param byteOffset
|
||||
* @param length
|
||||
*/
|
||||
static from(arrayBuffer: ArrayBuffer, byteOffset?: number, length?: number): Buffer;
|
||||
/**
|
||||
* Copies the passed {buffer} data onto a new Buffer instance.
|
||||
*
|
||||
* @param buffer
|
||||
*/
|
||||
static from(buffer: Buffer): Buffer;
|
||||
/**
|
||||
* Creates a new Buffer containing the given JavaScript string {str}.
|
||||
* If provided, the {encoding} parameter identifies the character encoding.
|
||||
* If not provided, {encoding} defaults to 'utf8'.
|
||||
*
|
||||
* @param str
|
||||
*/
|
||||
static from(str: string, encoding?: string): Buffer;
|
||||
/**
|
||||
* Returns true if {obj} is a Buffer
|
||||
*
|
||||
* @param obj object to test.
|
||||
*/
|
||||
static isBuffer(obj: any): obj is Buffer;
|
||||
/**
|
||||
* Returns true if {encoding} is a valid encoding argument.
|
||||
* Valid string encodings in Node 0.12: 'ascii'|'utf8'|'utf16le'|'ucs2'(alias of 'utf16le')|'base64'|'binary'(deprecated)|'hex'
|
||||
*
|
||||
* @param encoding string to test.
|
||||
*/
|
||||
static isEncoding(encoding: string): boolean;
|
||||
/**
|
||||
* Gives the actual byte length of a string. encoding defaults to 'utf8'.
|
||||
* This is not the same as String.prototype.length since that returns the number of characters in a string.
|
||||
*
|
||||
* @param string string to test.
|
||||
* @param encoding encoding used to evaluate (defaults to 'utf8')
|
||||
*/
|
||||
static byteLength(string: string, encoding?: string): number;
|
||||
/**
|
||||
* Returns a buffer which is the result of concatenating all the buffers in the list together.
|
||||
*
|
||||
* If the list has no items, or if the totalLength is 0, then it returns a zero-length buffer.
|
||||
* If the list has exactly one item, then the first item of the list is returned.
|
||||
* If the list has more than one item, then a new Buffer is created.
|
||||
*
|
||||
* @param list An array of Buffer objects to concatenate
|
||||
* @param totalLength Total length of the buffers when concatenated.
|
||||
* If totalLength is not provided, it is read from the buffers in the list. However, this adds an additional loop to the function, so it is faster to provide the length explicitly.
|
||||
*/
|
||||
static concat(list: Buffer[], totalLength?: number): Buffer;
|
||||
/**
|
||||
* The same as buf1.compare(buf2).
|
||||
*/
|
||||
static compare(buf1: Buffer, buf2: Buffer): number;
|
||||
/**
|
||||
* Allocates a new buffer of {size} octets.
|
||||
*
|
||||
* @param size count of octets to allocate.
|
||||
* @param fill if specified, buffer will be initialized by calling buf.fill(fill).
|
||||
* If parameter is omitted, buffer will be filled with zeros.
|
||||
* @param encoding encoding used for call to buf.fill while initalizing
|
||||
*/
|
||||
static alloc(size: number, fill?: string | Buffer | number, encoding?: string): Buffer;
|
||||
/**
|
||||
* Allocates a new buffer of {size} octets, leaving memory not initialized, so the contents
|
||||
* of the newly created Buffer are unknown and may contain sensitive data.
|
||||
*
|
||||
* @param size count of octets to allocate
|
||||
*/
|
||||
static allocUnsafe(size: number): Buffer;
|
||||
/**
|
||||
* Allocates a new non-pooled buffer of {size} octets, leaving memory not initialized, so the contents
|
||||
* of the newly created Buffer are unknown and may contain sensitive data.
|
||||
*
|
||||
* @param size count of octets to allocate
|
||||
*/
|
||||
static allocUnsafeSlow(size: number): Buffer;
|
||||
}
|
||||
}
|
||||
+62
@@ -0,0 +1,62 @@
|
||||
/* eslint-disable node/no-deprecated-api */
|
||||
var buffer = require('buffer')
|
||||
var Buffer = buffer.Buffer
|
||||
|
||||
// alternative to using Object.keys for old browsers
|
||||
function copyProps (src, dst) {
|
||||
for (var key in src) {
|
||||
dst[key] = src[key]
|
||||
}
|
||||
}
|
||||
if (Buffer.from && Buffer.alloc && Buffer.allocUnsafe && Buffer.allocUnsafeSlow) {
|
||||
module.exports = buffer
|
||||
} else {
|
||||
// Copy properties from require('buffer')
|
||||
copyProps(buffer, exports)
|
||||
exports.Buffer = SafeBuffer
|
||||
}
|
||||
|
||||
function SafeBuffer (arg, encodingOrOffset, length) {
|
||||
return Buffer(arg, encodingOrOffset, length)
|
||||
}
|
||||
|
||||
// Copy static methods from Buffer
|
||||
copyProps(Buffer, SafeBuffer)
|
||||
|
||||
SafeBuffer.from = function (arg, encodingOrOffset, length) {
|
||||
if (typeof arg === 'number') {
|
||||
throw new TypeError('Argument must not be a number')
|
||||
}
|
||||
return Buffer(arg, encodingOrOffset, length)
|
||||
}
|
||||
|
||||
SafeBuffer.alloc = function (size, fill, encoding) {
|
||||
if (typeof size !== 'number') {
|
||||
throw new TypeError('Argument must be a number')
|
||||
}
|
||||
var buf = Buffer(size)
|
||||
if (fill !== undefined) {
|
||||
if (typeof encoding === 'string') {
|
||||
buf.fill(fill, encoding)
|
||||
} else {
|
||||
buf.fill(fill)
|
||||
}
|
||||
} else {
|
||||
buf.fill(0)
|
||||
}
|
||||
return buf
|
||||
}
|
||||
|
||||
SafeBuffer.allocUnsafe = function (size) {
|
||||
if (typeof size !== 'number') {
|
||||
throw new TypeError('Argument must be a number')
|
||||
}
|
||||
return Buffer(size)
|
||||
}
|
||||
|
||||
SafeBuffer.allocUnsafeSlow = function (size) {
|
||||
if (typeof size !== 'number') {
|
||||
throw new TypeError('Argument must be a number')
|
||||
}
|
||||
return buffer.SlowBuffer(size)
|
||||
}
|
||||
+62
@@ -0,0 +1,62 @@
|
||||
{
|
||||
"_from": "safe-buffer@^5.1.2",
|
||||
"_id": "safe-buffer@5.1.2",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-Gd2UZBJDkXlY7GbJxfsE8/nvKkUEU1G38c1siN6QP6a9PT9MmHB8GnpscSmMJSoF8LOIrt8ud/wPtojys4G6+g==",
|
||||
"_location": "/mongodb-core/safe-buffer",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "range",
|
||||
"registry": true,
|
||||
"raw": "safe-buffer@^5.1.2",
|
||||
"name": "safe-buffer",
|
||||
"escapedName": "safe-buffer",
|
||||
"rawSpec": "^5.1.2",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "^5.1.2"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/mongodb-core"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.1.2.tgz",
|
||||
"_shasum": "991ec69d296e0313747d59bdfd2b745c35f8828d",
|
||||
"_spec": "safe-buffer@^5.1.2",
|
||||
"_where": "C:\\Users\\Luis\\source\\repos\\Modules\\Users\\server\\node_modules\\mongodb-core",
|
||||
"author": {
|
||||
"name": "Feross Aboukhadijeh",
|
||||
"email": "feross@feross.org",
|
||||
"url": "http://feross.org"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/feross/safe-buffer/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"deprecated": false,
|
||||
"description": "Safer Node.js Buffer API",
|
||||
"devDependencies": {
|
||||
"standard": "*",
|
||||
"tape": "^4.0.0"
|
||||
},
|
||||
"homepage": "https://github.com/feross/safe-buffer",
|
||||
"keywords": [
|
||||
"buffer",
|
||||
"buffer allocate",
|
||||
"node security",
|
||||
"safe",
|
||||
"safe-buffer",
|
||||
"security",
|
||||
"uninitialized"
|
||||
],
|
||||
"license": "MIT",
|
||||
"main": "index.js",
|
||||
"name": "safe-buffer",
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/feross/safe-buffer.git"
|
||||
},
|
||||
"scripts": {
|
||||
"test": "standard && tape test/*.js"
|
||||
},
|
||||
"types": "index.d.ts",
|
||||
"version": "5.1.2"
|
||||
}
|
||||
+87
@@ -0,0 +1,87 @@
|
||||
{
|
||||
"_from": "mongodb-core@3.1.3",
|
||||
"_id": "mongodb-core@3.1.3",
|
||||
"_inBundle": false,
|
||||
"_integrity": "sha512-dISiV3zHGJTwZpg0xDhi9zCqFGMhA5kDPByHlcaEp09NSKfzHJ7XQbqVrL7qhki1U9PZHsmRfbFzco+6b1h2wA==",
|
||||
"_location": "/mongodb-core",
|
||||
"_phantomChildren": {},
|
||||
"_requested": {
|
||||
"type": "version",
|
||||
"registry": true,
|
||||
"raw": "mongodb-core@3.1.3",
|
||||
"name": "mongodb-core",
|
||||
"escapedName": "mongodb-core",
|
||||
"rawSpec": "3.1.3",
|
||||
"saveSpec": null,
|
||||
"fetchSpec": "3.1.3"
|
||||
},
|
||||
"_requiredBy": [
|
||||
"/mongodb",
|
||||
"/mongoose"
|
||||
],
|
||||
"_resolved": "https://registry.npmjs.org/mongodb-core/-/mongodb-core-3.1.3.tgz",
|
||||
"_shasum": "b036bce5290b383fe507238965bef748dd8adb75",
|
||||
"_spec": "mongodb-core@3.1.3",
|
||||
"_where": "C:\\Users\\Luis\\source\\repos\\Modules\\Users\\server\\node_modules\\mongoose",
|
||||
"author": {
|
||||
"name": "Christian Kvalheim"
|
||||
},
|
||||
"bugs": {
|
||||
"url": "https://github.com/mongodb-js/mongodb-core/issues"
|
||||
},
|
||||
"bundleDependencies": false,
|
||||
"dependencies": {
|
||||
"bson": "^1.1.0",
|
||||
"require_optional": "^1.0.1",
|
||||
"safe-buffer": "^5.1.2",
|
||||
"saslprep": "^1.0.0"
|
||||
},
|
||||
"deprecated": false,
|
||||
"description": "Core MongoDB driver functionality, no bells and whistles and meant for integration not end applications",
|
||||
"devDependencies": {
|
||||
"chai": "^4.1.2",
|
||||
"chai-subset": "^1.6.0",
|
||||
"co": "^4.6.0",
|
||||
"eslint": "^4.6.1",
|
||||
"eslint-plugin-prettier": "^2.2.0",
|
||||
"jsdoc": "3.5.4",
|
||||
"mongodb-extjson": "^2.1.2",
|
||||
"mongodb-mock-server": "^1.0.0",
|
||||
"mongodb-test-runner": "^1.1.18",
|
||||
"prettier": "~1.12.0",
|
||||
"sinon": "^6.0.0",
|
||||
"snappy": "^6.0.1",
|
||||
"standard-version": "^4.4.0"
|
||||
},
|
||||
"homepage": "https://github.com/mongodb-js/mongodb-core",
|
||||
"keywords": [
|
||||
"mongodb",
|
||||
"core"
|
||||
],
|
||||
"license": "Apache-2.0",
|
||||
"main": "index.js",
|
||||
"name": "mongodb-core",
|
||||
"optionalDependencies": {
|
||||
"saslprep": "^1.0.0"
|
||||
},
|
||||
"peerOptionalDependencies": {
|
||||
"kerberos": "^1.0.0",
|
||||
"mongodb-extjson": "^2.1.2",
|
||||
"snappy": "^6.0.1",
|
||||
"bson-ext": "^2.0.0"
|
||||
},
|
||||
"repository": {
|
||||
"type": "git",
|
||||
"url": "git://github.com/mongodb-js/mongodb-core.git"
|
||||
},
|
||||
"scripts": {
|
||||
"atlas": "node ./test/atlas.js",
|
||||
"changelog": "conventional-changelog -p angular -i HISTORY.md -s",
|
||||
"coverage": "nyc node test/runner.js -t functional -l && node_modules/.bin/nyc report --reporter=text-lcov | node_modules/.bin/coveralls",
|
||||
"format": "prettier --print-width 100 --tab-width 2 --single-quote --write index.js 'test/**/*.js' 'lib/**/*.js'",
|
||||
"lint": "eslint index.js lib test",
|
||||
"release": "standard-version -i HISTORY.md",
|
||||
"test": "npm run lint && mongodb-test-runner -t 60000 test/tests"
|
||||
},
|
||||
"version": "3.1.3"
|
||||
}
|
||||
+3433
File diff suppressed because it is too large.
Load diff
Reference in new issue
Block a user