cassandra-driver
Version:
DataStax Node.js Driver for Apache Cassandra
139 lines (131 loc) • 5.08 kB
JavaScript
/*
* Copyright DataStax, Inc.
*
* 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.
*/
;
const dns = require('dns');
const util = require('util');
const utils = require('../utils');
/** @module policies/addressResolution */
/**
* @class
* @classdesc
* Translates IP addresses received from Cassandra nodes into locally queryable
* addresses.
* <p>
* The driver auto-detects new Cassandra nodes added to the cluster through server
* side pushed notifications and through checking the system tables. For each
* node, the address received will correspond to the address set as
* <code>rpc_address</code> in the node yaml file. In most case, this is the correct
* address to use by the driver and that is what is used by default. However,
* sometimes the addresses received through this mechanism will either not be
* reachable directly by the driver or should not be the preferred address to use
* to reach the node (for instance, the <code>rpc_address</code> set on Cassandra nodes
* might be a private IP, but some clients may have to use a public IP, or
* pass by a router to reach that node). This interface allows to deal with
* such cases, by allowing to translate an address as sent by a Cassandra node
* to another address to be used by the driver for connection.
* <p>
* Please note that the contact points addresses provided while creating the
* {@link Client} instance are not "translated", only IP address retrieve from or sent
* by Cassandra nodes to the driver are.
* @constructor
*/
function AddressTranslator() {
}
/**
* Translates a Cassandra <code>rpc_address</code> to another address if necessary.
* @param {String} address the address of a node as returned by Cassandra.
* <p>
* Note that if the <code>rpc_address</code> of a node has been configured to <code>0.0.0.0</code>
* server side, then the provided address will be the node <code>listen_address</code>,
* *not* <code>0.0.0.0</code>.
* </p>
* @param {Number} port The port number, as specified in the [protocolOptions]{@link ClientOptions} at Client instance creation (9042 by default).
* @param {Function} callback Callback to invoke with endpoint as first parameter.
* The endpoint is an string composed of the IP address and the port number in the format <code>ipAddress:port</code>.
*/
AddressTranslator.prototype.translate = function (address, port, callback) {
callback(address + ':' + port);
};
/**
* @class
* @classdesc
* {@link AddressTranslator} implementation for multi-region EC2 deployments <strong>where clients are also deployed in EC2</strong>.
* <p>
* Its distinctive feature is that it translates addresses according to the location of the Cassandra host:
* </p>
* <ul>
* <li>addresses in different EC2 regions (than the client) are unchanged</li>
* <li>addresses in the same EC2 region are <strong>translated to private IPs</strong></li>
* </ul>
* <p>
* This optimizes network costs, because Amazon charges more for communication over public IPs.
* </p>
* @constructor
*/
function EC2MultiRegionTranslator() {
}
util.inherits(EC2MultiRegionTranslator, AddressTranslator);
/**
* Addresses in the same EC2 region are translated to private IPs and addresses in
* different EC2 regions (than the client) are unchanged
*/
EC2MultiRegionTranslator.prototype.translate = function (address, port, callback) {
let newAddress = address;
const self = this;
let name;
utils.series([
function resolve(next) {
dns.reverse(address, function (err, hostNames) {
if (err) {
return next(err);
}
if (!hostNames) {
return next();
}
name = hostNames[0];
next();
});
},
function lookup(next) {
if (!name) {
return next();
}
dns.lookup(name, function (err, lookupAddress) {
if (err) {
return next(err);
}
newAddress = lookupAddress;
next();
});
}], function (err) {
if (err) {
//there was an issue while doing dns resolution
self.logError(address, err);
}
callback(newAddress + ':' + port);
});
};
/**
* Log method called to log errors that occurred while performing dns resolution.
* You can assign your own method to the class instance to do proper logging.
* @param {String} address
* @param {Error} err
*/
EC2MultiRegionTranslator.prototype.logError = function (address, err) {
//Do nothing by default
};
exports.AddressTranslator = AddressTranslator;
exports.EC2MultiRegionTranslator = EC2MultiRegionTranslator;