Revision a6e6fe48 snf-cyclades-app/synnefo/management/common.py
| b/snf-cyclades-app/synnefo/management/common.py | ||
|---|---|---|
| 1 |
# Copyright 2012 GRNET S.A. All rights reserved. |
|
| 1 |
# Copyright 2012-2014 GRNET S.A. All rights reserved.
|
|
| 2 | 2 |
# |
| 3 | 3 |
# Redistribution and use in source and binary forms, with or |
| 4 | 4 |
# without modification, are permitted provided that the following |
| ... | ... | |
| 35 | 35 |
from synnefo.db.models import (Backend, VirtualMachine, Network, |
| 36 | 36 |
Flavor, IPAddress, Subnet, |
| 37 | 37 |
BridgePoolTable, MacPrefixPoolTable, |
| 38 |
NetworkInterface, IPAddressLog)
|
|
| 38 |
NetworkInterface) |
|
| 39 | 39 |
from functools import wraps |
| 40 | 40 |
|
| 41 |
from django.conf import settings |
|
| 41 | 42 |
from snf_django.lib.api import faults |
| 42 | 43 |
from synnefo.api import util |
| 43 | 44 |
from synnefo.logic import backend as backend_mod |
| 44 | 45 |
from synnefo.logic.rapi import GanetiApiError, GanetiRapiClient |
| 45 | 46 |
from synnefo.logic.utils import (id_from_instance_name, |
| 46 |
id_from_network_name) |
|
| 47 |
|
|
| 47 |
id_from_network_name, |
|
| 48 |
id_from_nic_name) |
|
| 49 |
from django.core.exceptions import ObjectDoesNotExist |
|
| 48 | 50 |
import logging |
| 49 | 51 |
log = logging.getLogger(__name__) |
| 50 | 52 |
|
| ... | ... | |
| 55 | 57 |
else: |
| 56 | 58 |
return vm.operstate |
| 57 | 59 |
|
| 60 |
RESOURCE_MAP = {
|
|
| 61 |
"backend": Backend.objects, |
|
| 62 |
"flavor": Flavor.objects, |
|
| 63 |
"server": VirtualMachine.objects, |
|
| 64 |
"network": Network.objects, |
|
| 65 |
"subnet": Subnet.objects, |
|
| 66 |
"port": NetworkInterface.objects, |
|
| 67 |
"floating-ip": IPAddress.objects.filter(floating_ip=True)} |
|
| 68 |
|
|
| 69 |
|
|
| 70 |
def get_resource(name, value, for_update=False): |
|
| 71 |
"""Get object from DB based by it's ID |
|
| 72 |
|
|
| 73 |
Helper function for getting an object from DB by it's DB and raising |
|
| 74 |
appropriate command line errors if the object does not exist or the |
|
| 75 |
ID is invalid. |
|
| 58 | 76 |
|
| 59 |
def get_backend(backend_id): |
|
| 77 |
""" |
|
| 78 |
objects = RESOURCE_MAP[name] |
|
| 79 |
if name == "floating-ip": |
|
| 80 |
capital_name = "Floating IP" |
|
| 81 |
else: |
|
| 82 |
capital_name = name.capitalize() |
|
| 83 |
|
|
| 84 |
if name in ["server", "network", "port"]: |
|
| 85 |
try: |
|
| 86 |
if value.startswith(settings.BACKEND_PREFIX_ID): |
|
| 87 |
if name == "server": |
|
| 88 |
value = id_from_instance_name(value) |
|
| 89 |
elif name == "network": |
|
| 90 |
value = id_from_network_name(value) |
|
| 91 |
elif name == "port": |
|
| 92 |
value = id_from_nic_name(value) |
|
| 93 |
except ValueError: |
|
| 94 |
raise CommandError("Invalid {} ID: {}".format(capital_name, value))
|
|
| 95 |
|
|
| 96 |
if for_update: |
|
| 97 |
objects = objects.select_for_update() |
|
| 60 | 98 |
try: |
| 61 |
backend_id = int(backend_id) |
|
| 62 |
return Backend.objects.get(id=backend_id) |
|
| 63 |
except ValueError: |
|
| 64 |
raise CommandError("Invalid Backend ID: %s" % backend_id)
|
|
| 65 |
except Backend.DoesNotExist: |
|
| 66 |
raise CommandError("Backend with ID %s not found in DB. "
|
|
| 67 |
" Use snf-manage backend-list to find" |
|
| 68 |
" out available backend IDs." % backend_id) |
|
| 99 |
return objects.get(id=value) |
|
| 100 |
except ObjectDoesNotExist: |
|
| 101 |
msg = ("{0} with ID {1} does not exist. Use {2}-list to find out"
|
|
| 102 |
" available {2} IDs.")
|
|
| 103 |
raise CommandError(msg.format(capital_name, value, name)) |
|
| 104 |
except (ValueError, TypeError): |
|
| 105 |
raise CommandError("Invalid {} ID: {}".format(capital_name, value))
|
|
| 69 | 106 |
|
| 70 | 107 |
|
| 71 | 108 |
def get_image(image_id, user_id): |
| ... | ... | |
| 80 | 117 |
raise CommandError("image-id is mandatory")
|
| 81 | 118 |
|
| 82 | 119 |
|
| 83 |
def get_vm(server_id, for_update=False): |
|
| 84 |
"""Get a VirtualMachine object by its ID. |
|
| 85 |
|
|
| 86 |
@type server_id: int or string |
|
| 87 |
@param server_id: The server's DB id or the Ganeti name |
|
| 88 |
|
|
| 89 |
""" |
|
| 90 |
try: |
|
| 91 |
server_id = int(server_id) |
|
| 92 |
except (ValueError, TypeError): |
|
| 93 |
try: |
|
| 94 |
server_id = id_from_instance_name(server_id) |
|
| 95 |
except VirtualMachine.InvalidBackendIdError: |
|
| 96 |
raise CommandError("Invalid server ID: %s" % server_id)
|
|
| 97 |
|
|
| 98 |
try: |
|
| 99 |
objs = VirtualMachine.objects |
|
| 100 |
if for_update: |
|
| 101 |
objs = objs.select_for_update() |
|
| 102 |
return objs.get(id=server_id) |
|
| 103 |
except VirtualMachine.DoesNotExist: |
|
| 104 |
raise CommandError("Server with ID %s not found in DB."
|
|
| 105 |
" Use snf-manage server-list to find out" |
|
| 106 |
" available server IDs." % server_id) |
|
| 107 |
|
|
| 108 |
|
|
| 109 |
def get_network(network_id, for_update=True): |
|
| 110 |
"""Get a Network object by its ID. |
|
| 111 |
|
|
| 112 |
@type network_id: int or string |
|
| 113 |
@param network_id: The networks DB id or the Ganeti name |
|
| 114 |
|
|
| 115 |
""" |
|
| 116 |
|
|
| 117 |
try: |
|
| 118 |
network_id = int(network_id) |
|
| 119 |
except (ValueError, TypeError): |
|
| 120 |
try: |
|
| 121 |
network_id = id_from_network_name(network_id) |
|
| 122 |
except Network.InvalidBackendIdError: |
|
| 123 |
raise CommandError("Invalid network ID: %s" % network_id)
|
|
| 124 |
|
|
| 125 |
networks = Network.objects |
|
| 126 |
if for_update: |
|
| 127 |
networks = networks.select_for_update() |
|
| 128 |
try: |
|
| 129 |
return networks.get(id=network_id) |
|
| 130 |
except Network.DoesNotExist: |
|
| 131 |
raise CommandError("Network with ID %s not found in DB."
|
|
| 132 |
" Use snf-manage network-list to find out" |
|
| 133 |
" available network IDs." % network_id) |
|
| 134 |
|
|
| 135 |
|
|
| 136 |
def get_subnet(subnet_id, for_update=True): |
|
| 137 |
"""Get a Subnet object by its ID.""" |
|
| 138 |
try: |
|
| 139 |
subet_id = int(subnet_id) |
|
| 140 |
except (ValueError, TypeError): |
|
| 141 |
raise CommandError("Invalid subnet ID: %s" % subnet_id)
|
|
| 142 |
|
|
| 143 |
try: |
|
| 144 |
subnets = Subnet.objects |
|
| 145 |
if for_update: |
|
| 146 |
subnets.select_for_update() |
|
| 147 |
return subnets.get(id=subnet_id) |
|
| 148 |
except Subnet.DoesNotExist: |
|
| 149 |
raise CommandError("Subnet with ID %s not found in DB."
|
|
| 150 |
" Use snf-manage subnet-list to find out" |
|
| 151 |
" available subnet IDs" % subnet_id) |
|
| 152 |
|
|
| 153 |
|
|
| 154 |
def get_port(port_id, for_update=True): |
|
| 155 |
"""Get a port object by its ID.""" |
|
| 156 |
try: |
|
| 157 |
port_id = int(port_id) |
|
| 158 |
except (ValueError, TypeError): |
|
| 159 |
raise CommandError("Invalid port ID: %s" % port_id)
|
|
| 160 |
|
|
| 161 |
try: |
|
| 162 |
ports = NetworkInterface.objects |
|
| 163 |
if for_update: |
|
| 164 |
ports.select_for_update() |
|
| 165 |
return ports.get(id=port_id) |
|
| 166 |
except NetworkInterface.DoesNotExist: |
|
| 167 |
raise CommandError("Port with ID %s not found in DB."
|
|
| 168 |
" Use snf-manage port-list to find out" |
|
| 169 |
" available port IDs" % port_id) |
|
| 170 |
|
|
| 171 |
|
|
| 172 |
def get_flavor(flavor_id, for_update=False): |
|
| 173 |
try: |
|
| 174 |
flavor_id = int(flavor_id) |
|
| 175 |
objs = Flavor.objects |
|
| 176 |
if for_update: |
|
| 177 |
objs = objs.select_for_update() |
|
| 178 |
return objs.get(id=flavor_id) |
|
| 179 |
except ValueError: |
|
| 180 |
raise CommandError("Invalid flavor ID: %s", flavor_id)
|
|
| 181 |
except Flavor.DoesNotExist: |
|
| 182 |
raise CommandError("Flavor with ID %s not found in DB."
|
|
| 183 |
" Use snf-manage flavor-list to find out" |
|
| 184 |
" available flavor IDs." % flavor_id) |
|
| 185 |
|
|
| 186 |
|
|
| 187 |
def get_floating_ip_by_address(address, for_update=False): |
|
| 188 |
try: |
|
| 189 |
objects = IPAddress.objects |
|
| 190 |
if for_update: |
|
| 191 |
objects = objects.select_for_update() |
|
| 192 |
return objects.get(floating_ip=True, address=address, deleted=False) |
|
| 193 |
except IPAddress.DoesNotExist: |
|
| 194 |
raise CommandError("Floating IP does not exist.")
|
|
| 195 |
|
|
| 196 |
|
|
| 197 |
def get_floating_ip_log_by_address(address): |
|
| 198 |
try: |
|
| 199 |
objects = IPAddressLog.objects |
|
| 200 |
return objects.filter(address=address).order_by("released_at")
|
|
| 201 |
except IPAddressLog.DoesNotExist: |
|
| 202 |
raise CommandError("Floating IP does not exist or it hasn't be"
|
|
| 203 |
"attached to any server yet") |
|
| 204 |
|
|
| 205 |
|
|
| 206 |
def get_floating_ip_by_id(floating_ip_id, for_update=False): |
|
| 207 |
try: |
|
| 208 |
floating_ip_id = int(floating_ip_id) |
|
| 209 |
except (ValueError, TypeError): |
|
| 210 |
raise CommandError("Invalid floating-ip ID: %s" % floating_ip_id)
|
|
| 211 |
|
|
| 212 |
try: |
|
| 213 |
objects = IPAddress.objects |
|
| 214 |
if for_update: |
|
| 215 |
objects = objects.select_for_update() |
|
| 216 |
return objects.get(floating_ip=True, id=floating_ip_id, deleted=False) |
|
| 217 |
except IPAddress.DoesNotExist: |
|
| 218 |
raise CommandError("Floating IP %s does not exist." % floating_ip_id)
|
|
| 219 |
|
|
| 220 |
|
|
| 221 | 120 |
def check_backend_credentials(clustername, port, username, password): |
| 222 | 121 |
try: |
| 223 | 122 |
client = GanetiRapiClient(clustername, port, username, password) |
Also available in: Unified diff