from . import glance as gl_drv
from . import ceilometer as ce_drv
from . import cinder as ci_drv
-from . import portchain as port_drv
from . import utils as drv_utils
# Exceptions
import keystoneclient.exceptions as KeystoneExceptions
+import neutronclient.common.exceptions as NeutronException
class ValidationError(Exception):
self.glance_drv = gl_drv.GlanceDriver(self.sess_drv,
region_name = region,
logger = self.log)
-
- self.cinder_drv = ci_drv.CinderDriver(self.sess_drv,
+
+ try:
+ self.cinder_drv = ci_drv.CinderDriver(self.sess_drv,
region_name = region,
logger = self.log)
+ except Exception:
+ self.cinder_drv = None
self.ceilo_drv = ce_drv.CeilometerDriver(self.sess_drv,
region_name = region,
logger = self.log)
- self.portchain_drv = port_drv.L2PortChainDriver(self.sess_drv,
- self.neutron_drv,
- logger = self.log)
self.utils = DriverUtilities(self)
self._mgmt_network = mgmt_network
return self._cache['cinder']
def build_resource_cache(self):
- self.build_network_resource_cache()
+ try:
+ self.build_network_resource_cache()
+ except KeyError:
+ raise
self.build_nova_resource_cache()
self.build_cinder_resource_cache()
self.build_glance_resource_cache()
self.log.info("Discovering management network %s", self._mgmt_network)
network_list = self._cache_populate(self.neutron_drv.network_get,
None,
- **{'network_name':self._mgmt_network})
+ **{'network_name': self._mgmt_network})
if network_list:
self.neutron_cache['mgmt_net'] = network_list['id']
else:
- raise KeyError("Error")
+ msg = "Could not find management network %s" % self._mgmt_network
+ self.log.error(msg)
+ raise KeyError(msg)
def _build_glance_image_list(self):
self.log.info("Discovering images")
self.glance_cache['images'] = self._cache_populate(self.glance_image_list,
list())
+
return self.glance_cache['images']
+ def _build_cinder_volume_list(self):
+ self.log.info("Discovering volumes")
+ self.cinder_cache['volumes'] = self._cache_populate(self.cinder_volume_list,
+ list())
+ return self.cinder_cache['volumes']
def build_nova_resource_cache(self):
self.log.info("Building nova resource cache")
def build_network_resource_cache(self):
self.log.info("Building network resource cache")
- self._get_neutron_mgmt_network()
+ try:
+ self._get_neutron_mgmt_network()
+ except KeyError:
+ raise
self._build_neutron_security_group_list()
self._build_neutron_subnet_prefix_list()
def build_cinder_resource_cache(self):
- pass
-
+ self.log.info("Building cinder resource cache")
+ if self.cinder_drv is not None:
+ self._build_cinder_volume_list()
def build_glance_resource_cache(self):
self.log.info("Building glance resource cache")
else:
return self._build_glance_image_list()
+ @property
+ def _cinder_volume_list(self):
+ if 'volumes' in self.cinder_cache:
+ return self.cinder_cache['volumes']
+ else:
+ return self._build_cinder_volume_list()
+
def validate_account_creds(self):
try:
self.sess_drv.invalidate_auth_token()
self.sess_drv.auth_token
self.build_resource_cache()
+ except KeystoneExceptions.Unauthorized as e:
+ self.log.error("Invalid credentials ")
+ raise ValidationError("Invalid Credentials: "+ str(e))
except KeystoneExceptions.AuthorizationFailure as e:
self.log.error("Unable to authenticate or validate the existing credentials. Exception: %s", str(e))
raise ValidationError("Invalid Credentials: "+ str(e))
+ except NeutronException.NotFound as e:
+ self.log.error("Given management network could not be found for Openstack account ")
+ raise ValidationError("Neutron network not found "+ str(e))
except Exception as e:
self.log.error("Could not connect to Openstack. Exception: %s", str(e))
raise ValidationError("Connection Error: "+ str(e))
-
+
def glance_image_create(self, **kwargs):
- if not 'disk_format' in kwargs:
+ if 'disk_format' not in kwargs:
kwargs['disk_format'] = 'qcow2'
- if not 'container_format' in kwargs:
+ if 'container_format' not in kwargs:
kwargs['container_format'] = 'bare'
- if not 'min_disk' in kwargs:
+ if 'min_disk' not in kwargs:
kwargs['min_disk'] = 0
- if not 'min_ram' in kwargs:
+ if 'min_ram' not in kwargs:
kwargs['min_ram'] = 0
return self.glance_drv.image_create(**kwargs)
def nova_server_create(self, **kwargs):
if 'security_groups' not in kwargs:
- kwargs['security_groups'] = [ s['name'] for s in self._nova_security_groups ]
+ kwargs['security_groups'] = [s['name'] for s in self._nova_security_groups]
return self.nova_drv.server_create(**kwargs)
def nova_server_add_port(self, server_id, port_id):
def nova_volume_list(self, server_id):
return self.nova_drv.volume_list(server_id)
+ def neutron_extensions_list(self):
+ return self.neutron_drv.extensions_list()
+
def neutron_network_list(self):
return self.neutron_drv.network_list()
def ceilo_alarm_delete(self, alarm_id):
self.ceilo_drv.client.alarms.delete(alarm_id)
- def create_port_chain(self,name,port_lists):
- "Create port chain"
- #Create port pair
- ppgrp_list = list()
- for index,port_pair in enumerate(port_lists):
- ppair_list = list()
- ingress_port,egress_port = port_pair
- #Disable security group and port security for the port
- self.neutron_drv.port_update(ingress_port,no_security_groups=True,port_security_enabled=False)
- if ingress_port != egress_port:
- self.neutron_drv.port_update(egress_port,no_security_groups=True,port_security_enabled=False)
-
- ppair_id = self.portchain_drv.create_port_pair(name+'ppair'+str(index),ingress_port,egress_port)
- ppair_list.append(ppair_id)
- # Create port pair group
- ppgrp_id = self.portchain_drv.create_port_pair_group(name+'_ppgrp_'+str(index),ppair_list)
- ppgrp_list.append(ppgrp_id)
- #Create port chain
- port_chain_id = self.portchain_drv.create_port_chain(name,ppgrp_list)
- return port_chain_id
-
- def delete_port_chain(self,port_chain_id):
- "Delete port chain"
- try:
- result = self.portchain_drv.get_port_chain(port_chain_id)
- port_chain = result.json()
- self.log.debug("Port chain result is %s", port_chain)
- port_pair_groups = port_chain["port_chain"]["port_pair_groups"]
- self.portchain_drv.delete_port_chain(port_chain_id)
-
- # Get port pairs and delete port pair groups
- port_pairs = list()
- self.log.debug("Port pair groups during delete is %s", port_pair_groups)
- for port_pair_group_id in port_pair_groups:
- result = self.portchain_drv.get_port_pair_group(port_pair_group_id)
- port_pair_group = result.json()
- self.log.debug("Port pair group result is %s", port_pair_group)
- port_pairs.extend(port_pair_group["port_pair_group"]["port_pairs"])
- self.portchain_drv.delete_port_pair_group(port_pair_group_id)
-
- self.log.debug("Port pairs during delete is %s",port_pairs)
-
- for port_pair_id in port_pairs:
- self.portchain_drv.delete_port_pair(port_pair_id)
- pass
- except Exception as e:
- self.log.error("Error while delete port chain with id %s, exception %s", port_chain_id,str(e))
-
- def update_port_chain(self,port_chain_id,flow_classifier_list):
- result = self.portchain_drv.get_port_chain(port_chain_id)
- result.raise_for_status()
- port_chain = result.json()['port_chain']
- new_flow_classifier_list = list()
- if port_chain and port_chain['flow_classifiers']:
- new_flow_classifier_list.extend(port_chain['flow_classifiers'])
- new_flow_classifier_list.extend(flow_classifier_list)
- port_chain_id = self.portchain_drv.update_port_chain(port_chain['id'],flow_classifiers=new_flow_classifier_list)
- return port_chain_id
-
- def create_flow_classifer(self,classifier_name,classifier_dict):
- "Create flow classifier"
- flow_classifier_id = self.portchain_drv.create_flow_classifier(classifier_name,classifier_dict)
- return flow_classifier_id
-
- def delete_flow_classifier(self,classifier_id):
- "Create flow classifier"
- try:
- self.portchain_drv.delete_flow_classifier(classifier_id)
- except Exception as e:
- self.log.error("Error while deleting flow classifier with id %s, exception %s", classifier_id,str(e))
-
- def get_port_chain_list(self):
- result = self.portchain_drv.get_port_chain_list()
- port_chain_list = result.json()
- if 'port_chains' in port_chain_list:
- return port_chain_list['port_chains']
-
def cinder_volume_list(self):
return self.cinder_drv.volume_list()
- def cinder_volume_get(self,vol_id):
+ def cinder_volume_get(self, vol_id):
return self.cinder_drv.volume_get(vol_id)
def cinder_volume_set_metadata(self, volumeid, metadata):
projects / osm / SO.git / blobdiff