}).then(function(SecretAccessKey) {
ec2 = AWS.createEC2Client(AccessKeyId, SecretAccessKey);
ec2.version = "2012-07-20";
function prepare() {
return findRunningInstance().then(function(hostname) {
return ensureInstanceTags().then(function() {
return deploy(hostname);
});
});
}
if (pm.context.deploymentDescriptor.has(["config", "github.com/sourcemint/sdk-aws/0", "InstanceId"])) {
// TODO: If `options.bore` is set call `ensureSecurityGroup()` to ensure our public IP has access.
return prepare();
} else {
return ensureSSHKey().then(function() {
return ensureSecurityGroup().then(function() {
return createInstance().then(prepare);
});
});
}
});
//amazon helper
var OperationHelper = require('./lib/apac').OperationHelper;
var opHelper = new OperationHelper({
awsId: 'AKIAIAWX2JJWY7VX4UNQ',
awsSecret: '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',
assocId: '4778-2896-4669'
});
var app = module.exports = express.createServer(),
mongoose = require( 'mongoose' ); //MongoDB integration
//AWS load
var AWS = require('aws-lib');
var ec2 = AWS.createEC2Client("AKIAI3BFGQFNAIKYF3OQ", 'HABhz96nwwaweJYIYpAjkzmDoAaJO+8XkP55Q1CY');
var stripeApiKey = "";
var stripeApiKeyTesting = "..."
var stripe = require('stripe')(stripeApiKey);
// Configuration
app.configure(function(){
app.set('views', __dirname + '/views');
app.set('view engine', 'jade');
app.use(express.bodyParser());
app.use(express.methodOverride());
app.use(express.cookieParser());
app.use(express.session({secret: '1234567890QWERTY',maxAge: 3600000}));
// Initialize Passport! Also use passport.session() middleware, to support
var _ = require('underscore');
var lconfig = require('lconfig');
var logger = require('logger').logger('dawg-aws');
if (!lconfig.ec2) {
logger.error('You must set ec2.accessKeyId and ec2.secretKey in ' +
'config.json.');
process.exit(1);
}
var cloudwatch = aws.createCWClient(lconfig.ec2.accessKeyId,
lconfig.ec2.secretKey, { version: '2010-08-01' });
var ec2 = aws.createEC2Client(lconfig.ec2.accessKeyId,
lconfig.ec2.secretKey, { version: '2012-07-20' });
exports.estimatedCharges = function (cb) {
cloudwatch.call('GetMetricStatistics', {
'Dimensions.member.1.Name': 'Currency',
'Dimensions.member.1.Value': 'USD',
'Namespace': 'AWS/Billing',
'MetricName': 'EstimatedCharges',
'Period': 60 * 60 * 6,
'StartTime': new Date(Date.now() - 60 * 60 * 24 * 1000).toISOString(),
'EndTime': new Date().toISOString(),
'Statistics.member.1': 'Maximum',
'Unit': 'None'
}, function (err, res) {
if (err || !res ||
!res.GetMetricStatisticsResult ||
var aws = require("aws-lib");
ec2 = aws.createEC2Client(yourAccessKeyId, yourSecretAccessKey);
ec2.call("DescribeInstances", {}, function(result) {
console.log(JSON.stringify(result));
})
function allocateClient(endpoint) {
return aws.createEC2Client(process.env['AWS_ID'], process.env['AWS_SECRET'], {
version: '2011-12-15',
host: endpoint
});
}
module.exports = function (awsKey, awsSecretKey) {
var ec2 = aws.createEC2Client(awsKey, awsSecretKey);
//the api version that this library defaults to is ancient and doesn't support things like tagging
//so let's specify a more recent version
ec2.version = '2011-12-15';
function launchOnDemandInstances(params, callback) {
var options = {
'ImageId':params.ami,
'MinCount':1,
'MaxCount':params.numToLaunch,
'Placement.AvailabilityZone':params.awsZone,
'InstanceType':params.instanceType
};
//specify the security groups to launch in
for (var i = 0; i < params.securityGroups.length; i++) {
options['SecurityGroup.' + (i + 1)] = params.securityGroups[i];
}
ec2.call('RunInstances', options, function (err, response) {
//make sure we have an instance set in the response and return that
if (!response.instancesSet) {
err = 'Failure launching instance(s): ' + err;
}
else {
response = response.instancesSet;
}
callback(err, response);
});
}
function launchSpotInstances(params, callback) {
var options = {
'SpotPrice':params.spotPrice,
'InstanceCount':params.numToLaunch,
'LaunchSpecification.ImageId':params.ami,
'LaunchSpecification.InstanceType':params.instanceType,
'LaunchSpecification.Placement.AvailabilityZone':params.awsZone
};
//specify the security groups to launch in
for (var i = 0; i < params.securityGroups.length; i++) {
options['LaunchSpecification.SecurityGroup.' + (i + 1)] = params.securityGroups[i];
}
ec2.call('RequestSpotInstances', options, function (err, response) {
//make sure we have a valid state and return the response
if (!response.spotInstanceRequestSet) {
err = 'Failed to issue spot instance request \n ' + err;
}
else {
response = response.spotInstanceRequestSet.item;
if (response.state === 'cancelled' || response.state === 'failed') {
err = ' error issue spot instance request fault code is: ' + response.fault;
}
}
callback(err, response);
});
}
function getInstances(filters, callback) {
ec2.call('DescribeInstances', filters, function (err, response) {
var instances = [],
reservationSet;
try {
reservationSet = response.reservationSet.item;
for (var i = 0; i < reservationSet.length; i++) {
var instancesSet = reservationSet[i].instancesSet.item;
if (instancesSet instanceof Array) {
instances = instances.concat(instancesSet);
}
else {
instances.push(instancesSet);
}
}
}
catch (e) {
err = 'No instances found: ' + e + ' - ' + err;
instances = response;
}
callback(err, instances);
});
}
function getInstanceDescriptionFromPrivateIp(privateIp, callback) {
ec2.call('DescribeInstances', {'Filter.1.Name':'private-ip-address', 'Filter.1.Value':privateIp}, function (err, response) {
processInstanceDescription(err, response, callback);
});
}
function getInstanceDescriptionFromId(instanceId, callback) {
ec2.call('DescribeInstances', {'Filter.1.Name':'instance-id', 'Filter.1.Value':instanceId}, function (err, response) {
processInstanceDescription(err, response, callback);
});
}
function describeSpotInstanceRequest(requestId, callback) {
ec2.call('DescribeSpotInstanceRequests', {'Filter.1.Name':'spot-instance-request-id', 'Filter.1.Value':requestId}, function (err, response) {
if (!response.spotInstanceRequestSet) {
err = ' Failed to find spot instance request: ' + requestId + ' ' + err;
}
else {
response = response.spotInstanceRequestSet.item;
}
callback(err, response);
});
}
function terminateEc2Instance(instanceId, callback) {
ec2.call('TerminateInstances', {'InstanceId.1':instanceId}, function (err, response) {
var result;
try {
result = response.instancesSet.item.currentState.name;
}
catch (e) {
err = 'Failure terminating instance: ' + instanceId + ' ' + err;
}
if (!err && result !== 'shutting-down') {
err = 'Instance is not terminating ';
}
callback(err, response);
});
}
function cancelSpotRequest(requestId, callback) {
ec2.call('CancelSpotInstanceRequests', {'SpotInstanceRequestId.1':requestId}, function (err, response) {
if (!response.spotInstanceRequestSet) {
err = 'Failed to cancel spot request: ' + requestId + ' ' + err;
}
else {
response = response.spotInstanceRequestSet.item;
}
callback(err, response);
});
}
return {
launchOnDemandInstances:launchOnDemandInstances,
launchSpotInstances:launchSpotInstances,
getInstanceDescriptionFromPrivateIp:getInstanceDescriptionFromPrivateIp,
getInstanceDescriptionFromId:getInstanceDescriptionFromId,
getInstances:getInstances,
describeSpotInstanceRequest:describeSpotInstanceRequest,
terminateEc2Instance:terminateEc2Instance,
cancelSpotRequest:cancelSpotRequest
};
};
password: String,
first: String,
last: String,
email: String,
roles: [String],
shared: [{category: String, organisation: String, quantity: String}]
});
var UserModel = mongoose.model("UserModel", UserSchema);
//amazon start
var util = require('util');
var aws = require("aws-lib");
ec2 = aws.createEC2Client("AKIAIPJMAQNDYSJYRVUA", "oItVCSoe5LqKTKQBfysUij/LonsXF+BkRFEIyRGX");
var prodAdv = aws.createProdAdvClient("AKIAIPJMAQNDYSJYRVUA", "oItVCSoe5LqKTKQBfysUij/LonsXF+BkRFEIyRGX", "cs5-20");
var options = {SearchIndex: "Books", Keywords: "Javascript", ResponseGroup: "ItemAttributes,Offers,Images"};
app.get('/books', function (req, res) {
console.log(req);
prodAdv.call("ItemSearch", options, function(err, result) {
console.log(result);
res.json(result);
});
});
//amazon end
//ebay start
function createClient(opts) {
opts = opts || {}
var key = opts.key || process.env['AWS_KEY']
var secret = opts.key || process.env['AWS_SECRET']
var ec2 = aws.createEC2Client(key, secret, {
host: opts.host || "ec2.us-east-1.amazonaws.com"
})
return {
describeInstances: describeInstances,
launchInstances: launchInstances,
terminateInstances: terminateInstances,
instanceStatus: instanceStatus,
associateAddress: associateAddress
}
function describeInstances(ids, cb) {
var params = {}
ids.forEach(function(each, i) {
params['InstanceId.' + (i+1)] = each
})
ec2.call("DescribeInstances", params, function(err, res) {
if (err) return cb(err)
cb(null, utils.mapDescribeInstancesResponse(res))
})
}
function instanceStatus(ids, cb) {
var params = {}
ids.forEach(function(each, i) {
params['InstanceId.' + (i+1)] = each
})
ec2.call("DescribeInstanceStatus", params, function(err, res) {
if (err) return cb(err)
cb(null, utils.mapInstanceStatusResponse(res))
})
}
function launchInstances(opts, cb) {
var params = {
'ImageId' : opts.imageId,
'MinCount': opts.minCount || 1,
'MaxCount': opts.maxCount || opts.minCount || 1
}
if (opts.securityGroup) params['SecurityGroup'] = opts.securityGroup
if (opts.instanceType) params['InstanceType'] = opts.instanceType
if (opts.keyName) params['KeyName'] = opts.keyName
ec2.call("RunInstances", params, function(err, data) {
if (err) return cb(err)
cb(null, utils.mapLaunchInstancesResponse(data))
})
}
function terminateInstances(ids, cb) {
var params = {}
ids.forEach(function(each, i) {
params['InstanceId.' + (i+1)] = each
})
ec2.call("TerminateInstances", params, function(err, res) {
if (err) return cb(err)
cb(null, utils.mapTerminateInstancesResponse(res))
})
}
function associateAddress(opts, cb) {
var params = {
'PublicIp' : opts.publicIP,
'InstanceId' : opts.instanceId,
// 'AllowReassociation' : true
}
ec2.call("AssociateAddress", params, function(err, data){
if(err) return cb(err)
cb(null, utils.mapAssociateAddressResponse(data))
})
}
}
var aws = require("aws-lib");
ec2 = aws.createEC2Client('AKIAJTKL77XY7O3EJSLQ', 'e0pi8MtHDCs4m+0/QGBemCCYQ/nCoyFfTO+c//5v');
ec2.call("DescribeInstances", {}, function(err, result) {
console.log(JSON.stringify(result));
})
return function(cb) {
if (!config.accessKeyId) throw new Error('config missing accessKeyId')
if (!config.secretAccessKey) throw new Error('config missing secretAccessKey')
if (typeof cb != 'function') throw new Error('missing callback')
var ec2 = aws.createEC2Client(
config.accessKeyId,
config.secretAccessKey,
{ version: '2014-05-01' }
)
ec2.call('DescribeInstances', {}, function(err, result) {
if (err) return cb(err, [])
cb(null, filter(getInstancesFromResult()))
function getInstancesFromResult() {
var instances = []
result.reservationSet.item.forEach(function(instance) {
if (Array.isArray(instance.instancesSet.item)) {
instance.instancesSet.item.forEach(function(item) {
instances.push(item)
})
} else {
instances.push(instance.instancesSet.item)
}
})
return instances
}
function filter(instances) {
return instances.map(function(instance) {
return {
id: instance.instanceId,
type: instance.instanceType,
ipAddress: instance.ipAddress,
privateIpAddress: instance.privateIpAddress,
tags: getTags(instance),
online: instance.instanceState.name === 'running'
}
})
}
function getTags(instance) {
var tags = {}
var tagSet = getTagSet(instance)
tagSet.forEach(function(tag) {
if (typeof tag.value == 'string') {
tags[tag.key.toLowerCase()] = tag.value.toLowerCase()
}
else {
tags[tag.key.toLowerCase()] = ''
}
})
return tags
}
function getTagSet(instance) {
if (!instance.tagSet || !instance.tagSet.item) return []
var item = instance.tagSet.item
return Array.isArray(item) ? item : [ item ]
}
})
}
_(regions).each(function(region) {
clients[region] = aws.createEC2Client(options.awskey, options.awssecret,
{version: '2012-03-01', host: 'ec2.' + region + '.amazonaws.com'});
});
server.get('/instance_debug', function(req, res) {
ec2 = awslib.createEC2Client(key,secretKey);
ec2.call("DescribeInstances", {}, function(result) {
res.send(JSON.stringify(result));
});
});
}
try {
var config = JSON.parse(fs.readFileSync(argv.config, 'utf8'));
} catch(e) {
console.warn('Invalid JSON config file: ' + argv.config);
throw e;
}
if (!config.awsKey || !config.awsSecret) {
console.error('Missing awsKey and/or awsSecret in config file.')
process.exit(1);
}
// TODO: Determine how to support multiple AWS regions.
var ec2 = aws.createEC2Client(config.awsKey, config.awsSecret, {version: '2012-03-01'});
var swarm = {};
// List
swarm.list = function() {
Step(function() {
loadTags(this);
}, function(err, tags) {
if (err) throw err;
var swarms = _(tags).chain()
.filter(function(tag) { return tag.key === 'Swarm' })
.pluck('value')
.uniq().value();
console.log(swarms.join('\n'));
});
_(regions).each(function(region) {
clients[region] = aws.createEC2Client(config.awsKey, config.awsSecret,
{version: '2012-03-01', host: 'ec2.' + region + '.amazonaws.com'});
});
exports.connect = function(options, fn){
// XXX: need better way to pass around global variables.
this.client = aws.createEC2Client(options.key, options.secret, { version: '2013-02-01' });
if (fn) fn();
}
options[k] = argv[k] || options[k];
});
// Allow a single job to be passed in as cli args
if (argv.instanceid) {
var job = {};
_(['instanceid', 'pool', 'device', 'description']).each(function(key) {
if (!_(_(argv).keys()).include(key)) throw new Error('Option ' + key + ' is required when running a single job.');
job[key] = argv[key];
});
options.jobs = [job];
}
// version 2010-08-31 supports the 'Filter' parameter.
ec2 = aws.createEC2Client(options.awskey, options.awssecret,
{version: '2010-08-31', host: 'ec2.' + options.region + '.amazonaws.com'}
);
Step(function() {
exec('wget -q -O - http://169.254.169.254/latest/meta-data/instance-id', this);
}, function(err, selfInstanceId) {
if (err) throw err;
var group = this.group();
_.each(options.jobs, function(job) {
job.instanceid = job.instanceid === 'self' ? selfInstanceId : job.instanceid;
job.description = job.description + ' ' + job.device + ' ' + job.instanceid;
var params = {};
params['Filter.1.Name'] = 'attachment.device';
params['Filter.1.Value.1'] = job.device;
params['Filter.2.Name'] = 'attachment.instance-id';
params['Filter.2.Value.1'] = job.instanceid;