Skip to content

public / sequelize

Go to a project

不要怂，就是干，撸起袖子干！

Commit 971c1ab0 by Willyham
Options

Support forceWrite option to force query write pool

1 parent 7790c4fa
Inline Side-by-side
Showing with 101 additions and 102 deletions
lib/dialects/abstract/connection-manager.js
...@@ -12,8 +12,7 @@ var Pooling = require('generic-pool') ...@@ -12,8 +12,7 @@ var Pooling = require('generic-pool')
, ConnectionManager; , ConnectionManager;
ConnectionManager = function(dialect, sequelize) { ConnectionManager = function(dialect, sequelize) {
var config = sequelize.config var config = sequelize.config;
, self = this;
this.sequelize = sequelize; this.sequelize = sequelize;
this.config = config; this.config = config;
...@@ -28,7 +27,7 @@ ConnectionManager = function(dialect, sequelize) { ...@@ -28,7 +27,7 @@ ConnectionManager = function(dialect, sequelize) {
// If the user has turned off pooling we provide a 0/1 pool for backwards compat // If the user has turned off pooling we provide a 0/1 pool for backwards compat
config.pool = _.defaults({ config.pool = _.defaults({
max: 1, max: 1,
min: 0, min: 0
}, defaultPoolingConfig, { }, defaultPoolingConfig, {
validate: this.$validate.bind(this) validate: this.$validate.bind(this)
}); });
...@@ -68,123 +67,123 @@ ConnectionManager.prototype.initPools = function () { ...@@ -68,123 +67,123 @@ ConnectionManager.prototype.initPools = function () {
var self = this var self = this
, config = this.config; , config = this.config;
if (config.replication) { if (!config.replication) {
var reads = 0 this.pool = Pooling.Pool({
, writes = 0; name: 'sequelize-connection',
create: function(callback) {
self.$connect(config).nodeify(function (err, connection) {
callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit
});
},
destroy: function(connection) {
self.$disconnect(connection);
},
max: config.pool.max,
min: config.pool.min,
validate: config.pool.validate,
idleTimeoutMillis: config.pool.idle
});
return;
}
if (!Array.isArray(config.replication.read)) { var reads = 0;
config.replication.read = [config.replication.read];
}
// Make sure we don't modify the existing config object (user might re-use it) if (!Array.isArray(config.replication.read)) {
config.replication.write = _.extend({}, config.replication.write); config.replication.read = [config.replication.read];
config.replication.read = config.replication.read.map(function (read) { }
return _.extend({}, read);
}); // Make sure we don't modify the existing config object (user might re-use it)
config.replication.write = _.clone(config.replication.write);
config.replication.read = config.replication.read.map(function (read) {
return _.clone(read);
});
// Map main connection config
config.replication.write = _.defaults(config.replication.write, {
host: config.host,
port: config.port,
username: config.username,
password: config.password,
database: config.database
});
// Map main connection config // Apply defaults to each read config
config.replication.write = _.defaults(config.replication.write, { config.replication.read = _.map(config.replication.read, function(config) {
host: config.host, return _.defaults(config, {
port: config.port, host: self.config.host,
username: config.username, port: self.config.port,
password: config.password, username: self.config.username,
database: config.database password: self.config.password,
database: self.config.database
}); });
});
for (var i = 0; i < config.replication.read.length; i++) { // I'll make my own pool, with blackjack and hookers! (original credit goes to @janzeh)
config.replication.read[i] = _.defaults(config.replication.read[i], { this.pool = {
host: this.config.host, release: function(client) {
port: this.config.port, if (client.queryType === 'read') {
username: this.config.username, return self.pool.read.release(client);
password: this.config.password, } else {
database: this.config.database return self.pool.write.release(client);
}
},
acquire: function(callback, priority, queryType, forceWrite) {
forceWrite = _.isUndefined(forceWrite) ? false : forceWrite;
if (queryType === 'SELECT' && !forceWrite) {
self.pool.read.acquire(callback, priority);
} else {
self.pool.write.acquire(callback, priority);
}
},
destroy: function(connection) {
return self.pool[connection.queryType].destroy(connection);
},
destroyAllNow: function() {
self.pool.read.destroyAllNow();
self.pool.write.destroyAllNow();
},
drain: function(cb) {
self.pool.write.drain(function() {
self.pool.read.drain(cb);
}); });
} },
read: Pooling.Pool({
// I'll make my own pool, with blackjack and hookers! (original credit goes to @janzeh) name: 'sequelize-connection-read',
this.pool = { create: function(callback) {
release: function(client) { // Simple round robin config
if (client.queryType === 'read') { var nextRead = reads++ % config.replication.read.length;
return self.pool.read.release(client); self.$connect(config.replication.read[nextRead]).tap(function (connection) {
} else { connection.queryType = 'read';
return self.pool.write.release(client); }).nodeify(function (err, connection) {
} callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit
}, });
acquire: function(callback, priority, queryType) {
if (queryType === 'SELECT') {
self.pool.read.acquire(callback, priority);
} else {
self.pool.write.acquire(callback, priority);
}
}, },
destroy: function(connection) { destroy: function(connection) {
return self.pool[connection.queryType].destroy(connection); self.$disconnect(connection);
},
destroyAllNow: function() {
self.pool.read.destroyAllNow();
self.pool.write.destroyAllNow();
},
drain: function(cb) {
self.pool.write.drain(function() {
self.pool.read.drain(cb);
});
}, },
read: Pooling.Pool({ validate: config.pool.validate,
name: 'sequelize-connection-read', max: config.pool.max,
create: function(callback) { min: config.pool.min,
if (reads >= config.replication.read.length) { idleTimeoutMillis: config.pool.idle
reads = 0; }),
} write: Pooling.Pool({
// Simple round robin config name: 'sequelize-connection-write',
self.$connect(config.replication.read[reads++]).tap(function (connection) {
connection.queryType = 'read';
}).nodeify(function (err, connection) {
callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit
});
},
destroy: function(connection) {
self.$disconnect(connection);
},
validate: config.pool.validate,
max: config.pool.max,
min: config.pool.min,
idleTimeoutMillis: config.pool.idle
}),
write: Pooling.Pool({
name: 'sequelize-connection-write',
create: function(callback) {
self.$connect(config.replication.write).tap(function (connection) {
connection.queryType = 'write';
}).nodeify(function (err, connection) {
callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit
});
},
destroy: function(connection) {
self.$disconnect(connection);
},
validate: config.pool.validate,
max: config.pool.max,
min: config.pool.min,
idleTimeoutMillis: config.pool.idle
})
};
} else {
this.pool = Pooling.Pool({
name: 'sequelize-connection',
create: function(callback) { create: function(callback) {
self.$connect(config).nodeify(function (err, connection) { self.$connect(config.replication.write).tap(function (connection) {
connection.queryType = 'write';
}).nodeify(function (err, connection) {
callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit callback(err, connection); // For some reason this is needed, else generic-pool things err is a connection or some shit
}); });
}, },
destroy: function(connection) { destroy: function(connection) {
self.$disconnect(connection); self.$disconnect(connection);
}, },
validate: config.pool.validate,
max: config.pool.max, max: config.pool.max,
min: config.pool.min, min: config.pool.min,
validate: config.pool.validate,
idleTimeoutMillis: config.pool.idle idleTimeoutMillis: config.pool.idle
}); })
} };
}; };
ConnectionManager.prototype.getConnection = function(options) { ConnectionManager.prototype.getConnection = function(options) {
...@@ -195,7 +194,7 @@ ConnectionManager.prototype.getConnection = function(options) { ...@@ -195,7 +194,7 @@ ConnectionManager.prototype.getConnection = function(options) {
self.pool.acquire(function(err, connection) { self.pool.acquire(function(err, connection) {
if (err) return reject(err); if (err) return reject(err);
resolve(connection); resolve(connection);
}, options.priority, options.type); }, options.priority, options.type, options.forceWrite);
}); });
}; };
ConnectionManager.prototype.releaseConnection = function(connection) { ConnectionManager.prototype.releaseConnection = function(connection) {
......
Markdown is supported
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!