init

Hetzner.js

 const HetznerCloud = require('hcloud-js')
 let client
 let _ = require('lodash')
+let tokens
+const words = require('an-array-of-english-words')
+
+let oldG = '#!/bin/bash\n' +
+    'cd /root\n' +
+    'git clone http://git.fcfglobal.co/root/mt2.git\n' +
+    '    mv mt2 mt\n' +
+    'cd mt\n' +
+    'sudo chmod 777 *\n' +
+    'sudo ./install.sh\n' +
+    'cd ..\n' +
+    '    git clone http://git.fcfglobal.co/root/newhet.git\n' +
+    '    cd newhet\n' +
+    'echo ahmad > token.txt\n' +
+    'sudo chmod 777 *\n' +
+    'sudo ./run.sh\n' +
+    'sleep 20'
+
+let newG = '#!/bin/bash\n' +
+    'cd /root\n' +
+    'apt-get update -y\n' +
+    'apt install -y git\n' +
+    'git clone http://git.fcfglobal.co/root/Hetzner-Mt2-NewGeneration.git\n' +
+    '    mv Hetzner-Mt2-NewGeneration mt\n' +
+    'cd mt\n' +
+    'sudo chmod 777 *\n' +
+    'sudo ./install.sh\n' +
+    'cd ..\n' +
+    '    git clone http://git.fcfglobal.co/root/Hetzner-NewGeneration.git\n' +
+    '    mv Hetzner-NewGeneration newhet\n' +
+    '    cd newhet\n' +
+    'echo ahmad > token.txt\n' +
+    'sudo chmod 777 *\n' +
+    'sudo ./run.sh\n' +
+    'sleep 20'
+
 
 class Hetzner {
 
@@ -8,6 +44,7 @@ class Hetzner {
     constructor(token) {
 
         client = new HetznerCloud.Client(_.trim(token))
+        tokens = _.trim(token)
     }
 
 
@@ -26,6 +63,22 @@ class Hetzner {
     }
 
 
+    getAllFloatingIps() {
+        return new Promise(function (resolve, reject) {
+
+            client.floatingIPs.list().then(function (res) {
+
+                let d = _.values(res.floatingIPs);
+
+                resolve(d)
+
+            })
+        })
+
+
+    }
+
+
     async deleteServer(id) {
         return new Promise(function (resolve, reject) {
 
@@ -35,14 +88,22 @@ class Hetzner {
         })
     }
 
+    async delFloatingIp(id) {
+        return new Promise(function (resolve, reject) {
+
+            client.floatingIPs.delete(id).then(function (res) {
+                resolve(res)
+            })
+        })
+    }
+
     async removeByIp(ip) {
         try {
-            ip=_.trim(ip)
-            console.log('try to remove ip:'+ip)
+            ip = _.trim(ip)
+            console.log('try to remove ip:' + ip)
             let servers = await this.getAllServers()
             for (let i = 0; i < servers.length; i++) {
-                if (ip === servers[i].publicNet.server.publicNet.ipv4.ip)
-                {
+                if (ip === servers[i].publicNet.server.publicNet.ipv4.ip) {
 
                     await this.deleteServer(servers[i].id)
                 }
@@ -57,33 +118,155 @@ class Hetzner {
     }
 
 
-    async getAllFloatingIps() {
+    async removeFloatingIpByIp(ip) {
+        try {
+            ip = _.trim(ip)
+            console.log('try to remove ip:' + ip)
+            let ips = await this.getAllFloatingIps()
+            for (let i = 0; i < ips.length; i++) {
+                if (ip === ips[i].ip) {
+
+                    await this.delFloatingIp(ips[i].id)
+                }
+
+
+            }
+        } catch (e) {
+
+        }
+        return true
+
+    }
+
+
+    async removeAllFloatingIps() {
+        try {
+
+
+            let ips = await this.getAllFloatingIps()
+            for (let i = 0; i < ips.length; i++) {
+
+
+                await this.delFloatingIp(ips[i].id)
+
+
+            }
+        } catch (e) {
+
+        }
+        return true
+
+    }
+
+
+    async getIp() {
+        const request = require('request');
+        let url = 'http://admin.fcfglobal.co:3000/getIp/'
+        return new Promise(function (resolve, reject) {
+            request(url, {timeout: 15000}, function (error, res, body) {
+                resolve(body)
+
+            });
+        });
+
+    }
+
+    async getMasterServerId() {
+        try {
+
+            let ip = await this.getIp()
+            let servers = await this.getAllServers()
+
+
+            for (let i = 0; i < servers.length; i++) {
+                if (servers[i].publicNet.server.publicNet.ipv4.ip === ip) {
+
+                    return servers[i].id
+                }
+
+
+            }
+        } catch (e) {
+
+        }
+        return true
 
     }
 
 
-    deleteFloatingIp(id) {
+    createServer(region, newGeneration) {
+
+
+
+        let rand = randomInt(0, words.length)
+        return new Promise(function (resolve, reject) {
+
+            let command = newG
+
+            command = command.replace('ahmad', tokens)
+
+            client.servers.build(rand)
+                .serverType('cx51')
+                .location(region)
+                .userData(command)
+                .image('ubuntu-18.04')
+                .create()
+                .then(function (response) {
+                    resolve(response)
+                })
+                .catch(function (error) {
+                    console.log(error)
+                    reject(error)
+                    // Handle error...
+                })
+        })
 
     }
 
+    randomInt(low, high) {
+        return Math.floor(Math.random() * (high - low) + low)
+    }
 
-    createServer(name) {
+    createFloatingIp(location, server) {
 
         // nuremberg nbg1
         //fsn1
 
         return new Promise(function (resolve, reject) {
-            client.servers.build(name)
-                .serverType('cx51-ceph')
-                .location('fsn1')
-                .image('9541194')
-                .sshKey('ffgf')
+            client.floatingIPs.build()
+                .type('ipv4')
+                .location(location)
                 .create()
                 .then(function (response) {
+
+
                     resolve(response)
+
                 })
                 .catch(function (error) {
-                    // Handle error...
+                    resolve(false)
+                })
+        })
+
+    }
+
+
+    updateFlotingIP(id, serverId) {
+
+        // nuremberg nbg1
+        //fsn1
+
+        return new Promise(function (resolve, reject) {
+
+            client.floatingIPs.actions.assign(id,serverId)
+                .then(function (response) {
+                    let d = _.values(response.floatingIP);
+
+                    resolve(d)
+
+                })
+                .catch(function (error) {
+                    resolve(false)
                 })
         })
 

app.js

@@ -11,6 +11,7 @@ const fs = require('fs')
 const cronSpeed = require('node-cron');
 const shellExec = require('shell-exec')
 var decimalPointRegex = /\-?\d+\.\d+/g;
+let het
 app.get('/', (req, res) => {
     res.send('Hello World!')
     run()
@@ -64,24 +65,161 @@ cron.schedule('*/10 * * * * *', () => {
 
 postRequest()
 cronRemover.schedule(' */1 * * * *', () => {
+    init()
 
-    remover()
-    postRequest()
 });
 
+async function init() {
+    await initToken()
+    await addIp()
+    await attacher()
+    await remover()
+
+}
+
+
+async function checkIps(ip) {
+
+
+    let status = await getWorkFloating(ip)
+    status = parseInt(status)
+    switch (status) {
+        case 404:
+            await postFloatingIps([ip])
+            break
+        case 400:
+            await postFloatingIps([ip])
+            break
+        case 0:
+            await het.removeFloatingIpByIp(ip)
+            break
+        case 1:
+            break
+    }
+
+
+}
+
+async function checkServer(ip) {
+
+
+    let status = await getWorkMaster(ip)
+    status = parseInt(status)
+    switch (status) {
+        case 404:
+           // await postFloatingIps([ip])
+            break
+        case 400:
+          //  await postFloatingIps([ip])
+            break
+        case 0:
+            await het.removeByIp(ip)
+            break
+        case 1:
+            break
+    }
+
+
+}
+
+function getWorkFloating(ip) {
+    const request = require('request');
+    let url = 'http://admin.fcfglobal.co:3000/getIpDetail/' + ip
+    return new Promise(function (resolve, reject) {
+        request(url, {timeout: 15000}, function (error, res, body) {
+            resolve(body)
+
+        });
+    });
+
+}
+
+
+function getWorkMaster(ip) {
+    const request = require('request');
+    let url = 'http://admin.fcfglobal.co:3000/getMasterIpDetail/' + ip
+    return new Promise(function (resolve, reject) {
+        request(url, {timeout: 15000}, function (error, res, body) {
+            resolve(body)
+
+        });
+    });
+
+}
+
+function postFloatingIps(data) {
+
+    data = JSON.stringify(data)
+    data = cryptLib.encryptPlainTextWithRandomIV(data, key)
+
+
+    var options = {
+        method: 'POST',
+        url: 'http://admin.fcfglobal.co:3000/addFloatingIp',
+        headers: {'content-type': 'application/x-www-form-urlencoded'},
+        body: 'data=' + Buffer.from(data).toString('base64')
+
+    };
+
+
+    return new Promise(function (resolve, reject) {
+        request(options, function (error, response, body) {
+            if (error)
+                console.log(error)
+            resolve(true)
+
+        });
+    });
+}
+
+async function attacher() {
+    let serverId = await het.getMasterServerId()
+    serverId = parseInt(serverId)
+    let ips = await het.getAllFloatingIps()
+    let attached = false
+    for (let i = 0; i < ips.length; i++) {
+        if (typeof ips[i].server === "number") {
+            if (ips[i].server === serverId) {
+                attached = true
+                await postFloatingIps([ips[i].ip])
+                addBaship(ips[i].ip)
+                return checkIps(ips[i].ip)
+            }
+        }
+
+    }
+
+
+    for (let i = 0; i < ips.length; i++) {
+        if (typeof ips[i].server !== "number") {
+            await het.updateFlotingIP(ips[i].id, serverId)
+            await postFloatingIps([ips[i].ip])
+            addBaship(ips[i].ip)
+            break
+        }
+
 
-async function remover() {
-    let work = await getWork()
-    if (work === 'false') {
-        let ip = await getIp()
-        console.log(ip)
-        var contents = await fs.readFileSync('./token.txt', 'utf8');
-        let Hetzner = require('./Hetzner')
-        let het = new Hetzner(contents)
-        await het.removeByIp(ip)
     }
 
-    return  true
+    return true
+
+}
+
+async function initToken() {
+    var contents = await fs.readFileSync('./token.txt', 'utf8');
+    het = new Hetzner(contents)
+
+    //  remover()
+
+
+}
+
+
+async function remover() {
+    let ip=await getIp()
+    checkServer(ip)
+
+    return true
 
 
 }
@@ -150,34 +288,33 @@ function postRequest() {
     });
 }
 
-   async function calculateSpeed() {
+async function calculateSpeed() {
 
 
-        let d = await shellExec('vnstat -tr')
-        d = d.stdout
+    let d = await shellExec('vnstat -tr')
+    d = d.stdout
 
-        let arr = d.match(decimalPointRegex)
+    let arr = d.match(decimalPointRegex)
 
 
+    if (d.includes('kbit/s')) {
+        arr[0] = 1
+        arr[1] = 1
+    } else if (d.includes('Mbit/s')) {
 
-        if (d.includes('kbit/s')) {
-            arr[0] = 1
-            arr[1] = 1
-        } else if (d.includes('Mbit/s')) {
-
-        } else if (d.includes('Gbit/s')) {
-            arr[0] = arr[0] * 1000
-            arr[1] = arr[1] * 1000
-        } else if (d.includes('bit/s')) {
-            arr[0] = 1
-            arr[1] = 1
-        }
+    } else if (d.includes('Gbit/s')) {
+        arr[0] = arr[0] * 1000
+        arr[1] = arr[1] * 1000
+    } else if (d.includes('bit/s')) {
+        arr[0] = 1
+        arr[1] = 1
+    }
 
 
-        await sendRate(arr[0], arr[1])
+    await sendRate(arr[0], arr[1])
 
 
-    }
+}
 
 
 function sendRate(rx, tx) {

package.json

@@ -7,9 +7,11 @@
   },
   "dependencies": {
     "@skavinvarnan/cryptlib": "^1.0.3",
+    "an-array-of-english-words": "^2.0.0",
     "express": "~4.16.0",
     "hcloud-js": "^1.2.0",
     "lodash": "^4.17.15",
+    "moment-timezone": "^0.5.21",
     "node-cron": "^2.0.3",
     "request": "^2.88.0",
     "shell-exec": "^1.0.2",