Revision 0e9a423f snf-cyclades-app/synnefo/logic/reconciliation.py

b/snf-cyclades-app/synnefo/logic/reconciliation.py
58 58

  
59 59
import logging
60 60
import sys
61
import itertools
61 62

  
62 63
from django.core.management import setup_environ
63 64
try:
......
70 71

  
71 72
from datetime import datetime, timedelta
72 73

  
73
from synnefo.db.models import VirtualMachine
74
from synnefo.db.models import VirtualMachine, Network, BackendNetwork
74 75
from synnefo.util.dictconfig import dictConfig
75 76
from synnefo.util.rapi import GanetiApiError
76 77
from synnefo.logic.backend import get_ganeti_instances
......
186 187

  
187 188
    return snf_instances
188 189

  
190
#
191
# Nics
192
#
193
def get_nics_from_ganeti():
194
    """Get network interfaces for each ganeti instance.
195

  
196
    """
197
    instances = get_ganeti_instances(bulk=True)
198
    prefix = settings.BACKEND_PREFIX_ID
199

  
200
    snf_instances_nics = {}
201
    for i in instances:
202
        if i['name'].startswith(prefix):
203
            try:
204
                id = int(i['name'].split(prefix)[1])
205
            except Exception:
206
                log.error("Ignoring instance with malformed name %s",
207
                              i['name'])
208
                continue
209
            if id in snf_instances_nics:
210
                log.error("Ignoring instance with duplicate Synnefo id %s",
211
                    i['name'])
212
                continue
213

  
214
            ips = zip(itertools.repeat('ipv4'), i['nic.ips'])
215
            macs = zip(itertools.repeat('mac'), i['nic.macs'])
216
            networks = zip(itertools.repeat('network'), i['nic.networks'])
217
            # modes = zip(itertools.repeat('mode'), i['nic.modes'])
218
            # links = zip(itertools.repeat('link'), i['nic.links'])
219
            # nics = zip(ips,macs,modes,networks,links)
220
            nics = zip(ips, macs, networks)
221
            nics = map(lambda x:dict(x), nics)
222
            nics = dict(enumerate(nics))
223
            snf_instances_nics[id] = nics
224

  
225
    return snf_instances_nics
226

  
227

  
228
def get_nics_from_db():
229
    """Get network interfaces for each vm in DB.
230

  
231
    """
232
    instances = VirtualMachine.objects.filter(deleted=False)
233
    instances_nics = {}
234
    for instance in instances:
235
        nics = {}
236
        for n in instance.nics.all():
237
            ipv4 = n.ipv4
238
            nic = {'mac':      n.mac,
239
                   'network':  n.network.backend_id,
240
                   'ipv4':     ipv4 if ipv4 != '' else None
241
                   }
242
            nics[n.index] = nic
243
        instances_nics[instance.id] = nics
244
    return instances_nics
245

  
246

  
247
def unsynced_nics(DBNics, GNics):
248
    """Find unsynced network interfaces between DB and Ganeti.
249

  
250
    @ rtype: dict; {instance_id: ganeti_nics}
251
    @ return Dictionary containing the instances ids that have unsynced network
252
    interfaces between DB and Ganeti and the network interfaces in Ganeti.
253

  
254
    """
255
    idD = set(DBNics.keys())
256
    idG = set(GNics.keys())
257

  
258
    unsynced = {}
259
    for i in idD & idG:
260
        nicsD = DBNics[i]
261
        nicsG = GNics[i]
262
        if len(nicsD) != len(nicsG):
263
            unsynced[i] = (nicsD, nicsG)
264
            continue
265
        for index in nicsG.keys():
266
            nicD = nicsD[index]
267
            nicG = nicsG[index]
268
            if nicD['ipv4'] != nicG['ipv4'] or \
269
               nicD['mac'] != nicG['mac'] or \
270
               nicD['network'] != nicG['network']:
271
                   unsynced[i] = (nicsD, nicsG)
272
                   break
273

  
274
    return unsynced
275

  
276
#
277
# Networks
278
#
279
def get_networks_from_ganeti(backend):
280
    prefix = settings.BACKEND_PREFIX_ID
281

  
282
    networks = {}
283
    for net in backend.client.GetNetworks(bulk=True):
284
        if net['name'].startswith(prefix):
285
            # TODO: Get it from fun. Catch errors
286
            id = int(net['name'].split(prefix)[1])
287
            networks[id] = net
288

  
289
    return networks
290

  
291

  
292
def hanging_networks(backend, GNets):
293
    """Get networks that are not connected to all Nodegroups.
294

  
295
    """
296
    def get_network_groups(group_list):
297
        groups = set()
298
        for g in group_list:
299
            g_name = g.split('(')[0]
300
            groups.add(g_name)
301
        return groups
302

  
303
    groups = set(backend.client.GetGroups())
304

  
305
    hanging = {}
306
    for id, info in GNets.items():
307
        group_list = get_network_groups(info['group_list'])
308
        if group_list != groups:
309
            hanging[id] = groups - group_list
310
    return hanging
311

  
189 312

  
190 313
# Only for testing this module individually
191 314
def main():

Also available in: Unified diff