Statistics
| Branch: | Tag: | Revision:

root / snf-cyclades-app / synnefo / logic / reconciliation.py @ d7841399

History | View | Annotate | Download (10.1 kB)

1
#!/usr/bin/env python
2
# -*- coding: utf-8 -*-
3
#
4
# Copyright 2011 GRNET S.A. All rights reserved.
5
#
6
# Redistribution and use in source and binary forms, with or
7
# without modification, are permitted provided that the following
8
# conditions are met:
9
#
10
#   1. Redistributions of source code must retain the above
11
#      copyright notice, this list of conditions and the following
12
#      disclaimer.
13
#
14
#   2. Redistributions in binary form must reproduce the above
15
#      copyright notice, this list of conditions and the following
16
#      disclaimer in the documentation and/or other materials
17
#      provided with the distribution.
18
#
19
# THIS SOFTWARE IS PROVIDED BY GRNET S.A. ``AS IS'' AND ANY EXPRESS
20
# OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
21
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22
# PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL GRNET S.A OR
23
# CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24
# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25
# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
26
# USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27
# AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28
# LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29
# ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30
# POSSIBILITY OF SUCH DAMAGE.
31
#
32
# The views and conclusions contained in the software and
33
# documentation are those of the authors and should not be
34
# interpreted as representing official policies, either expressed
35
# or implied, of GRNET S.A.
36
#
37
"""Business logic for reconciliation
38

39
Reconcile the contents of the DB with the actual state of the
40
Ganeti backend.
41

42
Let D be the set of VMs in the DB, G the set of VMs in Ganeti.
43
RULES:
44
    R1. Stale servers in DB:
45
            For any v in D but not in G:
46
            Set deleted=True.
47
    R2. Orphan instances in Ganet:
48
            For any v in G with deleted=True in D:
49
            Issue OP_INSTANCE_DESTROY.
50
    R3. Unsynced operstate:
51
            For any v whose operating state differs between G and V:
52
            Set the operating state in D based on the state in G.
53
In the code, D, G are Python dicts mapping instance ids to operating state.
54
For D, the operating state is chosen from VirtualMachine.OPER_STATES.
55
For G, the operating state is True if the machine is up, False otherwise.
56

57
"""
58

    
59
import logging
60
import sys
61
import itertools
62

    
63
from django.core.management import setup_environ
64
try:
65
    from synnefo import settings
66
except ImportError:
67
    raise Exception("Cannot import settings, make sure PYTHONPATH contains "
68
                    "the parent directory of the Synnefo Django project.")
69
setup_environ(settings)
70

    
71

    
72
from datetime import datetime, timedelta
73

    
74
from synnefo.db.models import (VirtualMachine, pooled_rapi_client)
75
from synnefo.logic.rapi import GanetiApiError
76
from synnefo.logic.backend import get_ganeti_instances
77
from synnefo.logic import utils
78

    
79

    
80
log = logging.getLogger()
81

    
82

    
83
def stale_servers_in_db(D, G):
84
    idD = set(D.keys())
85
    idG = set(G.keys())
86

    
87
    stale = set()
88
    for i in idD - idG:
89
        if D[i] == 'BUILD':
90
            vm = VirtualMachine.objects.get(id=i)
91
            # Check time to avoid many rapi calls
92
            if datetime.now() > vm.backendtime + timedelta(seconds=5):
93
                with pooled_rapi_client(vm) as c:
94
                    try:
95
                        job_status = c.GetJobStatus(vm.backendjobid)['status']
96
                        if job_status in ('queued', 'waiting', 'running'):
97
                            # Server is still building in Ganeti
98
                            continue
99
                        else:
100
                            c.GetInstance(utils.id_to_instance_name(i))
101
                            # Server has just been created in Ganeti
102
                            continue
103
                    except GanetiApiError:
104
                        stale.add(i)
105
        else:
106
            stale.add(i)
107

    
108
    return stale
109

    
110

    
111
def orphan_instances_in_ganeti(D, G):
112
    idD = set(D.keys())
113
    idG = set(G.keys())
114

    
115
    return idG - idD
116

    
117

    
118
def unsynced_operstate(D, G):
119
    unsynced = set()
120
    idD = set(D.keys())
121
    idG = set(G.keys())
122

    
123
    for i in idD & idG:
124
        if (G[i] and D[i] != 'STARTED' or
125
            not G[i] and D[i] not in ('BUILD', 'ERROR', 'STOPPED')):
126
            unsynced.add((i, D[i], G[i]))
127
        if not G[i] and D[i] == 'BUILD':
128
            vm = VirtualMachine.objects.get(id=i)
129
            # Check time to avoid many rapi calls
130
            if datetime.now() > vm.backendtime + timedelta(seconds=5):
131
                with pooled_rapi_client(vm) as c:
132
                    try:
133
                        job_info = c.GetJobStatus(job_id=vm.backendjobid)
134
                        if job_info['status'] == 'success':
135
                            unsynced.add((i, D[i], G[i]))
136
                    except GanetiApiError:
137
                        pass
138

    
139
    return unsynced
140

    
141

    
142
def instances_with_build_errors(D, G):
143
    failed = set()
144
    idD = set(D.keys())
145
    idG = set(G.keys())
146

    
147
    for i in idD & idG:
148
        if not G[i] and D[i] == 'BUILD':
149
            vm = VirtualMachine.objects.get(id=i)
150
            # Check time to avoid many rapi calls
151
            if datetime.now() > vm.backendtime + timedelta(seconds=5):
152
                with pooled_rapi_client(vm) as c:
153
                    try:
154
                        job_info = c.GetJobStatus(job_id=vm.backendjobid)
155
                        if job_info['status'] == 'error':
156
                            failed.add(i)
157
                    except GanetiApiError:
158
                        failed.add(i)
159

    
160
    return failed
161

    
162

    
163
def get_servers_from_db():
164
    vms = VirtualMachine.objects.filter(deleted=False, backend__offline=False)
165
    return dict(map(lambda x: (x.id, x.operstate), vms))
166

    
167

    
168
def get_instances_from_ganeti():
169
    ganeti_instances = get_ganeti_instances(bulk=True)
170
    snf_instances = {}
171

    
172
    prefix = settings.BACKEND_PREFIX_ID
173
    for i in ganeti_instances:
174
        if i['name'].startswith(prefix):
175
            try:
176
                id = utils.id_from_instance_name(i['name'])
177
            except Exception:
178
                log.error("Ignoring instance with malformed name %s",
179
                              i['name'])
180
                continue
181

    
182
            if id in snf_instances:
183
                log.error("Ignoring instance with duplicate Synnefo id %s",
184
                    i['name'])
185
                continue
186

    
187
            snf_instances[id] = i['oper_state']
188

    
189
    return snf_instances
190

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

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

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

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

    
226
    return snf_instances_nics
227

    
228

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

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

    
247

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

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

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

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

    
275
    return unsynced
276

    
277
#
278
# Networks
279
#
280

    
281

    
282
def get_networks_from_ganeti(backend):
283
    prefix = settings.BACKEND_PREFIX_ID + 'net-'
284

    
285
    networks = {}
286
    with pooled_rapi_client(backend) as c:
287
        for net in c.GetNetworks(bulk=True):
288
            if net['name'].startswith(prefix):
289
                id = utils.id_from_network_name(net['name'])
290
                networks[id] = net
291

    
292
    return networks
293

    
294

    
295
def hanging_networks(backend, GNets):
296
    """Get networks that are not connected to all Nodegroups.
297

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

    
306
    with pooled_rapi_client(backend) as c:
307
        groups = set(c.GetGroups())
308

    
309
    hanging = {}
310
    for id, info in GNets.items():
311
        group_list = get_network_groups(info['group_list'])
312
        if group_list != groups:
313
            hanging[id] = groups - group_list
314
    return hanging
315

    
316

    
317
# Only for testing this module individually
318
def main():
319
    print get_instances_from_ganeti()
320

    
321

    
322
if __name__ == "__main__":
323
    sys.exit(main())