Skip to content

A
ai
Commit 14887235 authored by Ahmad Nemati's avatar Ahmad Nemati
Browse files
Options

init

parent 596b0de5
Show whitespace changes
Inline Side-by-side
Showing with 452 additions and 106 deletions
ai.js
View file @ 14887235
...@@ -98,6 +98,8 @@ let obj ...@@ -98,6 +98,8 @@ let obj
obj.maxAllocatedMoney=maxAllocatedMoney obj.maxAllocatedMoney=maxAllocatedMoney
obj.maxLevel=maxLevel obj.maxLevel=maxLevel
obj.step=step obj.step=step
obj.perReserve=Math.abs(((maxReserve * 100) / maxAllocatedMoney))
obj.perMeta=Math.abs(((maxMeta * 100) / maxAllocatedMoney))
} }
......
test_cal.js
View file @ 14887235
let fs = require('fs') var AWS = require('aws-sdk');
let _ = require('lodash') var shell = require('shelljs');
const request = require('request');
let drawDown=[30,40,50] let moment = require('moment-timezone')
let sort = 'profitPerMonth' let utils = require('./utils')
let alocatedReserve = 3 const fs = require('fs');
let alocatedReserveCompound = 3 const db = require('./../database/db')
let dir var lightsail
work()
class Amazon {
async function work() { constructor(account, regionParam, serverParam) {
var args = process.argv.slice(2); this.region = regionParam
dir = args[0] this.server = serverParam
let directory = await fs.readdirSync('last1000/'+dir)
for (let i = 0; i < directory.length; i = i + 1000) {
// console.log('hi') }
let arr = []
for (let j = 0; j < 1000; j++) { async init() {
let ip = await utils.getIp()
let acc = await db.getAccByIp(ip)
var config = new AWS.Config({
accessKeyId: acc.access, secretAccessKey: acc.secret, region: this.region
});
lightsail = new AWS.Lightsail(config)
}
async getIp(proxy) {
try { try {
if ((j + i) < directory.length)
arr.push(directory[j + i]) await this.deAttachStaticIp()
} catch (e) { } catch (e) {
} }
await this.attachStaticIp(proxy.instance)
await this.deAttachStaticIp()
let ip = await this.getIpAddressOfInstance(proxy.instance)
try {
await this.doRequest(ip)
} catch (e) {
await this.initFirewall(proxy.instance)
await this.doRequest(ip)
}
return ip
} }
if (arr.length !== 0) { async createInstance(snap, nparam) {
let timestamp = Date.now() let name
if (nparam)
name = nparam
else
name = 'Cluster' + this.randomInt(0, 500000)
await this.createInstanceFromSnashot(name, snap)
await this.sleep(15000)
// try {
// await this.initFirewall(name)
// }
// catch (e) {
//
// }
let ip
try { try {
await fs.mkdirSync('final1000/' +dir+'/'+ timestamp) ip = await this.getIpAddressOfInstance(name)
await fs.mkdirSync('final1000/' +dir+'/' + timestamp+'/default')
// for (let z=0;z<drawDown.length;z++)
// await fs.mkdirSync('final1000/' + timestamp+'/drawDown'+drawDown[z])
} catch (e) { } catch (e) {
} }
run('default','compound1000', arr, timestamp) // await this.doRequest(ip)
run('default','compound1000Start', arr, timestamp) //await rebootInstance(name)
run('default','profitPerMonth1000', arr, timestamp) return {name: name, ip: ip}
// generateByDrawDown(timestamp,arr) }
await run('default','profitPerMonth1000Start', arr, timestamp)
sleep(millis) {
return new Promise(resolve => setTimeout(resolve, millis));
}
attachStaticIp(instance) {
// run('profitPerMonth1000', arr, timestamp) let ipname = 'StaticIp-1'
// return new Promise(function (resolve, reject) {
//
// // run('percentage1000', arr, timestamp)
// run('compound1000', arr, timestamp) lightsail.attachStaticIp({staticIpName: ipname, instanceName: instance}
// run('profitPerMonth1000Start', arr, timestamp) , function (error, data) {
// await run('compound1000Start', arr, timestamp) if (error) {
// run('allocatedReservePerMonthUnder2', arr, timestamp) console.log(error)
// await run('allocatedReserveCompoundUnder2', arr, timestamp) reject('Error attachStaticIp')
} }
if (data)
resolve(true)
});
});
} }
}
async function generateByDrawDown(timestamp,arr) deAttachStaticIp() {
{
for (let i=0;i<drawDown.length;i++) let ipname = 'StaticIp-1'
return new Promise(function (resolve, reject) {
lightsail.detachStaticIp({staticIpName: ipname}, function (error, data) {
if (error) {
reject('Error deAttachStaticIp')
}
if (data)
resolve(true)
})
});
}
releaseStaticIp(name) {
return new Promise(function (resolve, reject) {
var params = {
staticIpName: name /* required */
};
lightsail.releaseStaticIp(params
, function (error, data) {
if (error)
reject('Error releaseStaticIp')
if (data)
resolve(true)
});
});
}
createSnapshutFromInstace() {
return new Promise(function (resolve, reject) {
var params = {
instanceName: 'Ubuntu-1', /* required */
instanceSnapshotName: 'snapx', /* required */
};
lightsail.createInstanceSnapshot(params, function (err, data) {
if (err)
reject('Error create snapx')
if (data)
resolve(true)
});
});
}
createStaticIp(name) {
return new Promise(function (resolve, reject) {
var params = {
staticIpName: name /* required */
};
lightsail.allocateStaticIp(params
, function (error, data) {
if (error) {
console.log(error)
reject('Error createStaticIp')
}
if (data)
resolve(data)
});
});
}
getAllInstances() {
return new Promise(function (resolve, reject) {
lightsail.getInstances(function (error, data) {
if (error) {
console.log(error)
reject('Error getAllInstances')
}
if (data)
resolve(data.instances)
})
});
}
getAllIps() {
return new Promise(function (resolve, reject) {
lightsail.getStaticIps(function (error, data) {
if (error)
reject('Error getAllIps')
if (data)
resolve(data.staticIps)
})
});
}
rebootInstance(proxy) {
return new Promise(function (resolve, reject) {
lightsail.rebootInstance({instanceName: proxy.instance}, function (error, data) {
if (error) {
console.log(error)
resolve(false)
}
if (data)
resolve(true)
})
});
}
getIpAddressOfInstance(instance) {
return new Promise(function (resolve, reject) {
lightsail.getInstance({instanceName: instance}, function (error, data) {
if (error) {
console.log(error)
reject('Error getIpAddressOfInstance')
}
if (data)
resolve(data.instance.publicIpAddress)
});
});
}
deleteInstance(instance) {
var params = {
instanceName: instance /* required */
};
return new Promise(function (resolve, reject) {
lightsail.deleteInstance(params, function (error, data) {
if (error)
reject('Error deleteInstance')
if (data)
resolve(data)
});
});
}
getInstance(instance) {
return new Promise(function (resolve, reject) {
lightsail.getInstance({instanceName: instance}, function (error, data) {
if (error)
reject('Error getInstance')
if (data)
resolve(data.instance)
});
});
}
initFirewall(instance) {
return new Promise(function (resolve, reject) {
var params = {
instanceName: instance,
portInfos: [
{ {
run('drawDown'+drawDown[i],'compound1000DrawDown'+drawDown[i], arr, timestamp) fromPort: 0,
run('drawDown'+drawDown[i],'compound1000StartDrawDown'+drawDown[i], arr, timestamp) protocol: 'all',
run('drawDown'+drawDown[i],'profitPerMonth1000DrawDown'+drawDown[i], arr, timestamp) toPort: 65535
await run('drawDown'+drawDown[i],'profitPerMonth1000StartDrawDown'+drawDown[i], arr, timestamp) },
]
};
lightsail.putInstancePublicPorts(params, function (error, data) {
if (error) {
console.log(error)
reject('Error putInstancePublicPorts')
}
if (data)
resolve(data)
});
});
}
copySnapShut(snap, region) {
return new Promise(function (resolve, reject) {
var params = {
sourceRegion: region,
targetSnapshotName: snap,
sourceSnapshotName: snap,
};
lightsail.copySnapshot(params, function (error, data) {
if (error) {
console.log(error)
reject('Error copySnapshot')
}
if (data)
resolve(data)
});
});
} }
}
async function run(root,name, directory, timestamp) { getInstanceOpenPort(instance) {
// let directory = await fs.readdirSync('last1000') return new Promise(function (resolve, reject) {
let arr2 = [] lightsail.getInstancePortStates({instanceName: instance}, function (error, data) {
let arrFinal = [] if (error)
let last = [] reject(error)
// console.log(directory) if (data)
for (let f = 0; f < directory.length; f++) { resolve(data)
if (typeof directory[f] === "undefined") });
continue });
console.log(directory[f]) }
arrFinal.push(readFile(root,name, directory[f]))
createInstanceFromSnashot(instanceName, snap) {
let reg = this.region
let server = this.server
return new Promise(function (resolve, reject) {
var params = {
availabilityZone: reg + 'a', /* required */
bundleId: server, /* required */
instanceNames: [instanceName],
instanceSnapshotName: snap, /* required */
};
lightsail.createInstancesFromSnapshot(params, function (error, data) {
if (error) {
console.log(error)
reject('Error createInstancesFromSnapshot')
} }
if (data)
resolve(data)
});
});
}
arrFinal = await Promise.all(arrFinal) createInstanceFromNormalWay() {
let reg = this.region
let server = 'large_2_0'
let command = " cd /home/ubuntu && " +
" git clone http://49.12.200.60/root/mt2oldAmazon.git" +
" && mv mt2oldAmazon mt" +
" && cd mt && chmod 777 " +
"* && ./install.sh && cd .." +
" && git clone http://49.12.200.60/root/rt2old.git " +
"&& mv rt2old rt2 && " +
"cd rt2 && chmod" +
" 777 * && ./run.sh && " +
"sudo pm2 start app.js && " +
"sudo pm2 startup && "
+ "sudo pm2 save && " +
"sleep 5 && reboot"
return new Promise(function (resolve, reject) {
var params = {
availabilityZone: reg + 'a', /* required */
blueprintId: 'ubuntu_18_04', /* required */
bundleId: 'large_2_0', /* required */
instanceNames: [ /* required */
'Ubuntu-1',
'Ubuntu-2'
for (let i = 0; i < arrFinal.length; i++) { ],
let inline = arrFinal[i] userData: command
// console.log(inline) };
if (reg === 'eu-north-1')
params.bundleId = 'large_2_3'
for (let z = 0; z < inline.length; z++) lightsail.createInstances(params, function (error, data) {
arr2.push(inline[z]) if (error) {
console.log(error)
reject('Error createInstancesFromNormalWay')
} }
if (data) {
console.log(data)
resolve(data)
}
// console.log(arr2) });
let t=name.toLowerCase() });
if (t.includes('per') || name === 'profitPerMonth1000' || name === 'allocatedReservePerMonthUnder3' || name === 'allocatedReservePerMonthUnder2' || name === 'profitPerMonth1000Start') }
last = _.orderBy(arr2, ['profitPerMonthDrawDown'], ['desc']);
// if (name === 'percentage1000') async foundInstance(meta) {
// last = _.orderBy(arr2, ['percentage'], ['asc']); let instance = await this.getAllInstances()
for (let i = 0; i < instance.length; i++) {
if (instance[i].name === meta) {
return {found: true, createdAt: instance[i].createdAt}
}
if (t.includes('compound') || name === 'compound1000' || name === 'allocatedReserveCompoundUnder3' || name === 'allocatedReserveCompoundUnder2' || name === 'compound1000Start') }
last = _.orderBy(arr2, ['CompoundPerMonthDrawDown'], ['desc']);
return {found: false}
}
let las = [] async foundNormalInstance(meta) {
for (let i = 0; i < 1000; i++) { let instance = await this.getAllInstances()
if (i < last.length) for (let i = 0; i < instance.length; i++) {
las.push(last[i]) if (instance[i].name === meta) {
return true
} }
}
createfileADV(root,timestamp, name, JSON.stringify(las, null, 2)) return false
last = []
}
}
async function readFile(root,name, directory) {
let sortByProfit = []
let file = await fs.readFileSync('./last1000/'+dir+'/' + directory + '/'+root+'/' + name + '.json', 'utf8')
file = JSON.parse(file)
// file = _.orderBy(file, sort, ['desc']); async getDaysCreate(meta) {
for (let j = 0; j < file.length; j++) { let instance = await this.getAllInstances()
for (let i = 0; i < instance.length; i++) {
if (instance[i].name === meta)
return this.getMinDays(instance[i].createdAt)
}
return false
sortByProfit.push(file[j])
} }
getMinDays(end) {
var now = moment(moment().tz('Asia/Tehran').format());
var end = moment.duration(now.diff(moment(end).tz('Asia/Tehran')));
return parseInt(end.asDays())
}
async isIpAlive(ip) {
let a = await shell.exec('ping ' + ip + ' -c 3', {silent: true}).stdout;
a = a.split(',')[2].split('%')[0]
a = parseInt(a)
return file return a <= 30
}
}
randomInt(low, high) {
return Math.floor(Math.random() * (high - low) + low)
}
function createfileADV(root,timestamp, filename, data) {
doRequest(ip) {
let url = 'http://' + ip + ':3000'
return new Promise(function (resolve, reject) { return new Promise(function (resolve, reject) {
fs.writeFile('final1000/'+dir+'/' + timestamp + '/'+root+'/' + filename + '.json', data, 'utf8', function (err) { request(url, {timeout: 6000}, function (error, res, body) {
if (err) reject(err); try {
else resolve(data); if (!error && res.statusCode === 200) {
resolve(body);
} else {
reject(error);
}
} catch (e) {
reject('Error Request');
}
}); });
}); });
}
} }
module.exports = Amazon;
\ No newline at end of file
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment