init

app.js

@@ -10,8 +10,9 @@ const request = require('request');
 const fs = require('fs')
 const cronSpeed = require('node-cron');
 const shellExec = require('shell-exec')
-let Hetzner = require('./Hetzner')
+let aruba = require('./aruba')
 let constant = require('./constant')
+let dc
 
 
 let het
@@ -28,50 +29,28 @@ app.get('/ip/:ip/', (req, res) => {
     return addNewIp(req, res)
 
 })
-
-app.get('/add/:num/', (req, res) => {
-    // console.log(req.params.acc)
-    return newFloatingIpsOrder(req, res)
-
-})
-
-app.get('/del/', (req, res) => {
-    // console.log(req.params.acc)
-    res.send('Done')
-    het.removeAllFloatingIps()
-
-})
-
-app.get('/test', (req, res) => {
-    // console.log(req.params.acc)
-    res.sendfile('jetmtp.png')
-
-})
+//
+// app.get('/add/:num/', (req, res) => {
+//     // console.log(req.params.acc)
+//     return newFloatingIpsOrder(req, res)
+//
+// })
+//
+// app.get('/del/', (req, res) => {
+//     // console.log(req.params.acc)
+//     res.send('Done')
+//     het.removeAllFloatingIps()
+//
+// })
+//
+// app.get('/test', (req, res) => {
+//     // console.log(req.params.acc)
+//     res.sendfile('jetmtp.png')
+//
+// })
 
 
-async function newFloatingIpsOrder(req, res) {
-    let order = parseInt(req.params.num)
-    res.send('Floating Ips from ' + (order === 1 ? 'Nuremberg' : 'Falkenstein') + ' Requested')
-    let ips = await het.getAllFloatingIps()
-    if (ips.length === 10)
-        return
-    let masterid = await het.getMasterServerId()
-    let floatNum = 10 - ips.length
-    let location = order === 1 ? constant.nuremberg : constant.falkenstein
 
-    let newIps = []
-
-    for (let i = 1; i <= floatNum; i++) {
-
-        let ip = await het.createFloatingIp(location, masterid)
-        addBaship(ip)
-
-        newIps.push(ip)
-    }
-
-    // console.log(req.params.ip)
-    // addBaship(req.params.ip)
-}
 
 async function addBaship(ip) {
     return shell.exec(' ip addr add ' + ip + ' dev eth0').stderr;
@@ -105,42 +84,47 @@ cronRemover.schedule(' */1 * * * *', () => {
 
 });
 init()
+
 async function init() {
     await initToken()
     postRequest()
     checkIps()
 }
 
+async function addIPs(ip) {
+    await aruba.attachedToServerByIp(dc, ip)
+    addBaship(ip)
+    await postFloatingIps([ip])
+}
 
 async function checkIps() {
-    let ips = await het.getAllFloatingIps()
+    let ips = await aruba.getAllIps()
     for (let i = 0; i < ips.length; i++) {
 
-        let status = await getWorkFloating(ips[i].ip)
+        let status = await getWorkFloating(ips[i].Value)
         status = parseInt(status)
         switch (status) {
             case 404:
-                await postFloatingIps([ips[i].ip])
+                await addIPs(ips[i].Value)
                 break
             case 400:
-                await postFloatingIps([ips[i].ip])
+                await addIPs(ips[i].Value)
                 break
             case 0:
-                await het.delFloatingIp(ips[i].id)
+                 await aruba.RemovedByIp(ips[i].Value)
                 break
             case 1:
+                await addIPs(ips[i].Value)
                 break
         }
 
 
-
     }
 }
 
 async function initToken() {
-    var contents = await fs.readFileSync('./token.txt', 'utf8');
-    het = new Hetzner(contents)
-
+    await aruba.init()
+    dc = aruba.getDc()
     //  remover()
 
 
@@ -148,9 +132,8 @@ async function initToken() {
 
 
 async function addNewIp(req, res) {
-    res.send('Hello World!')
-    console.log(req.params.ip)
-    addBaship(req.params.ip)
+    res.send('Done')
+    await aruba.createFloatingIp(dc)
 }
 
 function postFloatingIps(data) {
@@ -161,7 +144,7 @@ function postFloatingIps(data) {
 
     var options = {
         method: 'POST',
-        url: 'http://admin.fcfglobal.co:3000/addFloatingIp',
+        url: 'http://admin.fcfglobal.co:3000/addFloatingIpAruba',
         headers: {'content-type': 'application/x-www-form-urlencoded'},
         body: 'data=' + Buffer.from(data).toString('base64')
 
@@ -240,7 +223,7 @@ function getIp() {
 }
 
 function postRequest() {
-    let data = {generation: generation, groups: groups}
+    let data = {generation: generation, groups: groups, instance: 'Aruba'}
     data = JSON.stringify(data)
     data = cryptLib.encryptPlainTextWithRandomIV(data, key)
 

aruba.js

+const request = require('request');
+let post = 'post'
+let _ = require('lodash')
+let auth = {Username: "AWI-236440", Password: "QVMUB653$H"}
+let ip
+let AvailDc = [1, 2, 3, 4, 5, 6, 7, 8]
+let foundDc
+let masterIp
+let networkId
+let serverId
+
+//test()
+
+async function test() {
+
+    //  getNewIp('b.','1','EU-West-1')
+    // await init()
+    // console.log(foundDc)
+    // let d=await unAttachedToServer(1,)
+    // for(let i=0;i<10;i++)
+    // {
+    //   let f=  await createFloatingIp(1)
+    //     console.log(f)
+    // }
+    // let ips = await getAllIps(1)
+    // console.log(ips)
+    await deleteAllIps(1)
+
+}
+
+
+
+async function init() {
+    ip = await getIp()
+    for (let i = 0; i < AvailDc.length; i++) {
+        let servers = await getAllServers(AvailDc[i])
+        servers = servers.Value
+        if (servers.length === 0)
+            continue
+
+        for (let j = 0; j < servers.length; j++) {
+
+            let server = await getDetailsofServer(AvailDc[i], servers[j].ServerId)
+            server = server.Value
+            if (ip === server.NetworkAdapters[0].IPAddresses[0].Value) {
+                masterIp = server.NetworkAdapters[0].IPAddresses[0].Value
+                networkId = server.NetworkAdapters[0].Id
+                serverId = server.ServerId
+                foundDc = AvailDc[i]
+                break
+            }
+
+        }
+
+
+    }
+}
+
+
+async function getAllServers(dc) {
+    let url = generateUrl(dc, 'GetServers')
+
+    let d = await doRequest(url, auth)
+
+    return d
+}
+
+async function getDetailsofServer(dc, id) {
+    let url = generateUrl(dc, 'GetServerDetails')
+
+    let body = auth
+    body.ServerId = id
+    let d = await doRequest(url, body)
+
+    return d
+}
+
+async function createFloatingIp(dc) {
+    let url = generateUrl(dc, 'SetPurchaseIpAddress')
+
+    let d = await doRequest(url, auth)
+    d = d.Value
+   await attachedToServer(dc, d.ResourceId)
+    return d
+}
+
+async function getAllIps(dc) {
+    let url = generateUrl(dc, 'GetPurchasedIpAddresses')
+
+    let d = await doRequest(url, auth)
+
+    return d.Value
+}
+
+async function deleteAllIps(dc) {
+    let ips=await getAllIps(dc)
+    for(let i=0;i<ips.length;i++)
+    {
+        if (ips[i].Value !== masterIp)
+        {
+            let d=await deleteIp(dc,ips[i].ResourceId)
+            console.log(d)
+        }
+
+    }
+
+
+    return 'Done'
+}
+
+
+
+
+async function attachedToServer(dc, resourceId) {
+    let url = generateUrl(dc, 'SetEnqueueAssociateIpAddress')
+
+    let body = auth
+    body.IpRequest = {NetworkAdapterId: networkId, IpAddressResourceIds: [resourceId]}
+    let d = await doRequest(url, body)
+
+    return d
+
+
+}
+
+
+async function unAttachedToServer(dc, resourceId) {
+    let url = generateUrl(dc, 'SetEnqueueDeassociateIpAddress')
+
+    let body = auth
+    body.IpRequest = {NetworkAdapterId: networkId, IpAddressResourceIds: [resourceId]}
+    let d = await doRequest(url, body)
+
+    return d
+
+
+}
+
+
+async function attachedToServerByIp(dc, ip) {
+    let ips=await getAllIps(dc)
+
+    for(let i=0;i<ips.length ;i++)
+    {
+        if (ips[i].Value === ip)
+        {
+            await attachedToServer(dc,ips[i].ResourceId)
+            break
+        }
+    }
+
+
+    return 'Done'
+
+
+}
+
+
+async function RemovedByIp(dc, ip) {
+    let ips=await getAllIps(dc)
+
+    for(let i=0;i<ips.length ;i++)
+    {
+        if (ips[i].Value === ip)
+        {
+            await deleteIp(dc,ips[i].ResourceId)
+            break
+        }
+    }
+
+
+    return 'Done'
+
+
+}
+
+async function deleteIp(dc, id) {
+    await unAttachedToServer(dc, id)
+    let url = generateUrl(dc, 'SetRemoveIpAddress')
+    let body = auth
+    body.IpAddressResourceId = id
+    let d = await doRequest(url, body)
+
+    return d
+
+}
+
+
+function getDc()
+{
+    return foundDc
+}
+
+
+async function doRequest(url, body) {
+
+
+    var options = {
+        method: post,
+        url: url,
+        timeout: 20000,
+        headers:
+            {
+                'Content-Type':
+                    'application/json'
+            }
+        ,
+        body: JSON.stringify(body)
+
+    };
+
+
+    return new Promise(function (resolve, reject) {
+        request(options, function (error, response, body) {
+            if (error) reject('Problem With Request Cherry Servers')
+            try {
+
+
+                resolve(JSON.parse(body))
+
+            } catch (e) {
+                resolve(true)
+                //  console.log('Problem --->' + options.url)
+                // console.log(e)
+
+            }
+
+        });
+    });
+}
+
+
+async function doLocalRequest(mainIp, addIp) {
+
+
+    let base = 'http://' + mainIp + ':3000/ip/' + addIp
+    console.log(base)
+    var options = {
+        method: 'get',
+        url: base,
+        timeout: 20000,
+        headers: {
+            'accept': 'application/json',
+            'Authorization': 'Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXUyJ9.eyJjbGllbnRfaWQiOjYxMTYxLCJpYXQiOjE1NzUyNDM0MDR9.s0l_J_EIvcgWbvQHXwrS3h3I8CY0pkdsWux0O1pUwTo'
+        }
+
+    };
+
+
+    return new Promise(function (resolve, reject) {
+        request(options, function (error, response, body) {
+            if (error) reject('Problem With Request Cherry Servers')
+            try {
+
+
+                resolve(true)
+
+            } catch (e) {
+                resolve(true)
+                //  console.log('Problem --->' + options.url)
+                // console.log(e)
+
+            }
+
+        });
+    });
+}
+
+function generateUrl(dc, endpoint) {
+    return 'https://api.dc' + dc + '.computing.cloud.it/WsEndUser/v2.9/WsEndUser.svc/json/' + endpoint
+}
+
+function 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)
+
+        });
+    });
+
+}
+
+module.exports =
+    {
+        init:init,
+        getAllIps:getAllIps,
+        getDc:getDc,
+        attachedToServerByIp:attachedToServerByIp,
+        RemovedByIp:RemovedByIp,
+        createFloatingIp:createFloatingIp
+
+
+    }