def disconnect_switch_port(self, switch_port_name, vnic_deleted, delete_port): """Disconnects the switch port.""" switch_svc = self._conn.Msvm_VirtualSwitchManagementService()[0] switch_port_path = self._get_switch_port_path_by_name(switch_port_name) if not switch_port_path: # Port not found. It happens when the VM was already deleted. return if not vnic_deleted: (ret_val, ) = switch_svc.DisconnectSwitchPort( SwitchPort=switch_port_path) if ret_val != 0: data = { 'switch_port_name': switch_port_name, 'ret_val': ret_val } raise HyperVException( msg=_('Failed to disconnect port %(switch_port_name)s ' 'with error %(ret_val)s') % data) if delete_port: (ret_val, ) = switch_svc.DeleteSwitchPort( SwitchPort=switch_port_path) if ret_val != 0: data = { 'switch_port_name': switch_port_name, 'ret_val': ret_val } raise HyperVException( msg=_('Failed to delete port %(switch_port_name)s ' 'with error %(ret_val)s') % data)
def disconnect_switch_port(self, switch_port_name, vnic_deleted, delete_port): """Disconnects the switch port.""" switch_svc = self._conn.Msvm_VirtualSwitchManagementService()[0] switch_port_path = self._get_switch_port_path_by_name( switch_port_name) if not switch_port_path: # Port not found. It happens when the VM was already deleted. return if not vnic_deleted: (ret_val, ) = switch_svc.DisconnectSwitchPort( SwitchPort=switch_port_path) if ret_val != 0: data = {'switch_port_name': switch_port_name, 'ret_val': ret_val} raise HyperVException( msg=_('Failed to disconnect port %(switch_port_name)s ' 'with error %(ret_val)s') % data) if delete_port: (ret_val, ) = switch_svc.DeleteSwitchPort( SwitchPort=switch_port_path) if ret_val != 0: data = {'switch_port_name': switch_port_name, 'ret_val': ret_val} raise HyperVException( msg=_('Failed to delete port %(switch_port_name)s ' 'with error %(ret_val)s') % data)
def create_default_reject_all_rules(self, switch_port_name): port, found = self._get_switch_port_allocation(switch_port_name, False) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) acls = port.associators(wmi_result_class=self._PORT_EXT_ACL_SET_DATA) filtered_acls = [v for v in acls if v.Action == self._ACL_ACTION_DENY] if len(filtered_acls) >= self._REJECT_ACLS_COUNT: return for acl in filtered_acls: self._remove_virt_feature(acl) weight = 0 ipv4_pair = (self._ACL_TYPE_IPV4, self._IPV4_ANY) ipv6_pair = (self._ACL_TYPE_IPV6, self._IPV6_ANY) for direction in [self._ACL_DIR_IN, self._ACL_DIR_OUT]: for acl_type, address in [ipv4_pair, ipv6_pair]: for protocol in [self._TCP_PROTOCOL, self._UDP_PROTOCOL, self._ICMP_PROTOCOL]: self._bind_security_rule( port, direction, acl_type, self._ACL_ACTION_DENY, self._ACL_DEFAULT, protocol, address, weight) weight += 1
def _provision_network(self, port_id, net_uuid, network_type, physical_network, segmentation_id): LOG.info(_LI("Provisioning network %s"), net_uuid) vswitch_name = self._get_vswitch_name(network_type, physical_network) if network_type == constants.TYPE_VLAN: # Nothing to do pass elif network_type == constants.TYPE_NVGRE and self._nvgre_enabled: self._nvgre_ops.bind_nvgre_network( segmentation_id, net_uuid, vswitch_name) elif network_type == constants.TYPE_FLAT: # Nothing to do pass elif network_type == constants.TYPE_LOCAL: # TODO(alexpilotti): Check that the switch type is private # or create it if not existing pass else: raise exception.NetworkingHyperVException( (_("Cannot provision unknown network type %(network_type)s" " for network %(net_uuid)s") % dict(network_type=network_type, net_uuid=net_uuid))) map = { 'network_type': network_type, 'vswitch_name': vswitch_name, 'ports': [], 'vlan_id': segmentation_id} self._network_vswitch_map[net_uuid] = map
def _get_vswitch(self, vswitch_name): vswitch = self._conn.Msvm_VirtualEthernetSwitch( ElementName=vswitch_name) if not len(vswitch): raise utils.HyperVException(msg=_('VSwitch not found: %s') % vswitch_name) return vswitch[0]
def _init_nvgre(self): # if NVGRE is enabled, self._nvgre_ops is required in order to properly # set the agent state (see get_agent_configrations method). if not CONF.NVGRE.enable_support: return if not CONF.NVGRE.provider_tunnel_ip: err_msg = _( "enable_nvgre_support is set to True, but provider " "tunnel IP is not configured. Check neutron.conf " "config file." ) LOG.error(err_msg) raise utils.HyperVException(msg=err_msg) self._nvgre_enabled = True self._nvgre_ops = nvgre_ops.HyperVNvgreOps(list(self._physical_network_mappings.values())) self._nvgre_ops.init_notifier(self.context, self.client) self._nvgre_ops.tunnel_update(self.context, CONF.NVGRE.provider_tunnel_ip, constants.TYPE_NVGRE) # setup Hyper-V Agent Lookup Record update consumer topic = hyperv_agent_notifier.get_topic_name(self.topic, constants.LOOKUP, constants.UPDATE) self.connection.create_consumer(topic, self.endpoints, fanout=True) # the created consumer is the last connection server. # need to start it in order for it to consume. self.connection.servers[-1].start()
def set_vswitch_port_vlan_id(self, vlan_id, switch_port_name): port_alloc, found = self._get_switch_port_allocation(switch_port_name) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) vlan_settings = self._get_vlan_setting_data_from_port_alloc(port_alloc) if vlan_settings: if (vlan_settings.OperationMode == self._OPERATION_MODE_ACCESS and vlan_settings.AccessVlanId == vlan_id): # VLAN already set to corect value, no need to change it. return # Removing the feature because it cannot be modified # due to a wmi exception. self._remove_virt_feature(vlan_settings) # remove from cache. self._vlan_sds.pop(port_alloc.InstanceID, None) vlan_settings = self._create_default_setting_data( self._PORT_VLAN_SET_DATA) vlan_settings.AccessVlanId = vlan_id vlan_settings.OperationMode = self._OPERATION_MODE_ACCESS self._add_virt_feature(port_alloc, vlan_settings)
def _provision_network(self, port_id, net_uuid, network_type, physical_network, segmentation_id): LOG.info(_LI("Provisioning network %s"), net_uuid) vswitch_name = self._get_vswitch_name(network_type, physical_network) if network_type == constants.TYPE_VLAN: # Nothing to do pass elif network_type == constants.TYPE_NVGRE and self._nvgre_enabled: self._nvgre_ops.bind_nvgre_network(segmentation_id, net_uuid, vswitch_name) elif network_type == constants.TYPE_FLAT: # Nothing to do pass elif network_type == constants.TYPE_LOCAL: # TODO(alexpilotti): Check that the switch type is private # or create it if not existing pass else: raise exception.NetworkingHyperVException( (_("Cannot provision unknown network type %(network_type)s" " for network %(net_uuid)s") % dict(network_type=network_type, net_uuid=net_uuid))) map = { 'network_type': network_type, 'vswitch_name': vswitch_name, 'ports': [], 'vlan_id': segmentation_id } self._network_vswitch_map[net_uuid] = map
def _init_nvgre(self): # if NVGRE is enabled, self._nvgre_ops is required in order to properly # set the agent state (see get_agent_configrations method). if not CONF.NVGRE.enable_support: return if not CONF.NVGRE.provider_tunnel_ip: err_msg = _('enable_nvgre_support is set to True, but provider ' 'tunnel IP is not configured. Check neutron.conf ' 'config file.') LOG.error(err_msg) raise utils.HyperVException(msg=err_msg) self._nvgre_enabled = True self._nvgre_ops = nvgre_ops.HyperVNvgreOps( list(self._physical_network_mappings.values())) self._nvgre_ops.init_notifier(self.context, self.client) self._nvgre_ops.tunnel_update(self.context, CONF.NVGRE.provider_tunnel_ip, constants.TYPE_NVGRE) # setup Hyper-V Agent Lookup Record update consumer topic = hyperv_agent_notifier.get_topic_name(self.topic, constants.LOOKUP, constants.UPDATE) self.connection.create_consumer(topic, self.endpoints, fanout=True) # the created consumer is the last connection server. # need to start it in order for it to consume. self.connection.servers[-1].start()
def set_vswitch_port_vlan_id(self, vlan_id, switch_port_name): port_alloc, found = self._get_switch_port_allocation(switch_port_name) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) vlan_settings = self._get_vlan_setting_data_from_port_alloc(port_alloc) if vlan_settings: if (vlan_settings.OperationMode == self._OPERATION_MODE_ACCESS and vlan_settings.AccessVlanId == vlan_id): # VLAN already set to corect value, no need to change it. return # Removing the feature because it cannot be modified # due to a wmi exception. self._remove_virt_feature(vlan_settings) # remove from cache. self._vlan_sds.pop(port_alloc.InstanceID, None) vlan_settings = self._get_default_setting_data( self._PORT_VLAN_SET_DATA) vlan_settings.AccessVlanId = vlan_id vlan_settings.OperationMode = self._OPERATION_MODE_ACCESS self._add_virt_feature(port_alloc, vlan_settings)
def _provision_network(self, port_id, net_uuid, network_type, physical_network, segmentation_id): LOG.info(_LI("Provisioning network %s"), net_uuid) vswitch_name = self._get_vswitch_name(network_type, physical_network) if network_type == constants.TYPE_VLAN: self._utils.set_switch_external_port_trunk_vlan( vswitch_name, segmentation_id, constants.TRUNK_ENDPOINT_MODE) elif network_type == constants.TYPE_FLAT: # Nothing to do pass elif network_type == constants.TYPE_LOCAL: # TODO(alexpilotti): Check that the switch type is private # or create it if not existing pass else: raise utils.HyperVException( msg=(_("Cannot provision unknown network type %(network_type)s" " for network %(net_uuid)s") % dict(network_type=network_type, net_uuid=net_uuid))) map = { 'network_type': network_type, 'vswitch_name': vswitch_name, 'ports': [], 'vlan_id': segmentation_id} self._network_vswitch_map[net_uuid] = map
def set_vswitch_port_vlan_id(self, vlan_id, switch_port_name): port_alloc, found = self._get_switch_port_allocation(switch_port_name) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) vs_man_svc = self._conn.Msvm_VirtualSystemManagementService()[0] vlan_settings = self._get_vlan_setting_data_from_port_alloc(port_alloc) if vlan_settings: if (vlan_settings.OperationMode == self._OPERATION_MODE_ACCESS and vlan_settings.AccessVlanId == vlan_id): # VLAN already set to corect value, no need to change it. return # Removing the feature because it cannot be modified # due to a wmi exception. (job_path, ret_val) = vs_man_svc.RemoveFeatureSettings( FeatureSettings=[vlan_settings.path_()]) self._check_job_status(ret_val, job_path) (vlan_settings, found) = self._get_vlan_setting_data(switch_port_name) vlan_settings.AccessVlanId = vlan_id vlan_settings.OperationMode = self._OPERATION_MODE_ACCESS (job_path, out, ret_val) = vs_man_svc.AddFeatureSettings( port_alloc.path_(), [vlan_settings.GetText_(1)]) self._check_job_status(ret_val, job_path)
def deprecated(self, msg, *args, **kwargs): """Call this method when a deprecated feature is used. If the system is configured for fatal deprecations then the message is logged at the 'critical' level and :class:`DeprecatedConfig` will be raised. Otherwise, the message will be logged (once) at the 'warn' level. :raises: :class:`DeprecatedConfig` if the system is configured for fatal deprecations. """ stdmsg = _("Deprecated: %s") % msg if CONF.fatal_deprecations: self.critical(stdmsg, *args, **kwargs) raise DeprecatedConfig(msg=stdmsg) # Using a list because a tuple with dict can't be stored in a set. sent_args = self._deprecated_messages_sent.setdefault(msg, list()) if args in sent_args: # Already logged this message, so don't log it again. return sent_args.append(args) self.warn(stdmsg, *args, **kwargs)
def _check_job_status(self, ret_val, jobpath): """Poll WMI job state for completion.""" if not ret_val: return elif ret_val not in [WMI_JOB_STATE_STARTED, WMI_JOB_STATE_RUNNING]: raise HyperVException(msg=_('Job failed with error %d') % ret_val) job_wmi_path = jobpath.replace('\\', '/') job = wmi.WMI(moniker=job_wmi_path) while job.JobState == WMI_JOB_STATE_RUNNING: time.sleep(0.1) job = wmi.WMI(moniker=job_wmi_path) if job.JobState != WMI_JOB_STATE_COMPLETED: job_state = job.JobState if job.path().Class == "Msvm_ConcreteJob": err_sum_desc = job.ErrorSummaryDescription err_desc = job.ErrorDescription err_code = job.ErrorCode data = { 'job_state': job_state, 'err_sum_desc': err_sum_desc, 'err_desc': err_desc, 'err_code': err_code } raise HyperVException( msg=_("WMI job failed with status %(job_state)d. " "Error details: %(err_sum_desc)s - %(err_desc)s - " "Error code: %(err_code)d") % data) else: (error, ret_val) = job.GetError() if not ret_val and error: data = {'job_state': job_state, 'error': error} raise HyperVException( msg=_("WMI job failed with status %(job_state)d. " "Error details: %(error)s") % data) else: raise HyperVException( msg=_("WMI job failed with status %d. " "No error description available") % job_state) desc = job.Description elap = job.ElapsedTime LOG.debug("WMI job succeeded: %(desc)s, Elapsed=%(elap)s", { 'desc': desc, 'elap': elap })
def _check_job_status(self, ret_val, jobpath): """Poll WMI job state for completion.""" if not ret_val: return elif ret_val not in [WMI_JOB_STATE_STARTED, WMI_JOB_STATE_RUNNING]: raise HyperVException(msg=_('Job failed with error %d') % ret_val) job_wmi_path = jobpath.replace('\\', '/') job = wmi.WMI(moniker=job_wmi_path) while job.JobState == WMI_JOB_STATE_RUNNING: time.sleep(0.1) job = wmi.WMI(moniker=job_wmi_path) if job.JobState != WMI_JOB_STATE_COMPLETED: job_state = job.JobState if job.path().Class == "Msvm_ConcreteJob": err_sum_desc = job.ErrorSummaryDescription err_desc = job.ErrorDescription err_code = job.ErrorCode data = {'job_state': job_state, 'err_sum_desc': err_sum_desc, 'err_desc': err_desc, 'err_code': err_code} raise HyperVException( msg=_("WMI job failed with status %(job_state)d. " "Error details: %(err_sum_desc)s - %(err_desc)s - " "Error code: %(err_code)d") % data) else: (error, ret_val) = job.GetError() if not ret_val and error: data = {'job_state': job_state, 'error': error} raise HyperVException( msg=_("WMI job failed with status %(job_state)d. " "Error details: %(error)s") % data) else: raise HyperVException( msg=_("WMI job failed with status %d. " "No error description available") % job_state) desc = job.Description elap = job.ElapsedTime LOG.debug("WMI job succeeded: %(desc)s, Elapsed=%(elap)s", {'desc': desc, 'elap': elap})
def _is_port_vm_started(self, port): vmsettings = port.associators( wmi_result_class=self._VIRTUAL_SYSTEM_SETTING_DATA) # See http://msdn.microsoft.com/en-us/library/cc160706%28VS.85%29.aspx (ret_val, summary_info) = self._vs_man_svc.GetSummaryInformation( [self._VM_SUMMARY_ENABLED_STATE], [v.path_() for v in vmsettings]) if ret_val or not summary_info: raise utils.HyperVException(msg=_('Cannot get VM summary data ' 'for: %s') % port.ElementName) return summary_info[0].EnabledState is self._HYPERV_VM_STATE_ENABLED
def _create_switch_port(self, vswitch_name, switch_port_name): """Creates a switch port.""" switch_svc = self._conn.Msvm_VirtualSwitchManagementService()[0] vswitch_path = self._get_vswitch(vswitch_name).path_() (new_port, ret_val) = switch_svc.CreateSwitchPort(Name=switch_port_name, FriendlyName=switch_port_name, ScopeOfResidence="", VirtualSwitch=vswitch_path) if ret_val != 0: raise HyperVException(msg=_('Failed creating port for %s') % vswitch_name) return new_port
def _create_switch_port(self, vswitch_name, switch_port_name): """Creates a switch port.""" switch_svc = self._conn.Msvm_VirtualSwitchManagementService()[0] vswitch_path = self._get_vswitch(vswitch_name).path_() (new_port, ret_val) = switch_svc.CreateSwitchPort( Name=switch_port_name, FriendlyName=switch_port_name, ScopeOfResidence="", VirtualSwitch=vswitch_path) if ret_val != 0: raise HyperVException( msg=_('Failed creating port for %s') % vswitch_name) return new_port
def _init_nvgre(self): # if NVGRE is enabled, self._nvgre_ops is required in order to properly # set the agent state (see get_agent_configrations method). if not CONF.NVGRE.enable_support: return if not CONF.NVGRE.provider_tunnel_ip: err_msg = _('enable_nvgre_support is set to True, but provider ' 'tunnel IP is not configured. Check neutron.conf ' 'config file.') LOG.error(err_msg) raise exception.NetworkingHyperVException(err_msg) self._nvgre_enabled = True self._nvgre_ops = nvgre_ops.HyperVNvgreOps( list(self._physical_network_mappings.values())) self._nvgre_ops.init_notifier(self.context, self.client) self._nvgre_ops.tunnel_update(self.context, CONF.NVGRE.provider_tunnel_ip, constants.TYPE_NVGRE)
def _find_facility_from_conf(): facility_names = logging.handlers.SysLogHandler.facility_names facility = getattr(logging.handlers.SysLogHandler, CONF.syslog_log_facility, None) if facility is None and CONF.syslog_log_facility in facility_names: facility = facility_names.get(CONF.syslog_log_facility) if facility is None: valid_facilities = facility_names.keys() consts = ['LOG_AUTH', 'LOG_AUTHPRIV', 'LOG_CRON', 'LOG_DAEMON', 'LOG_FTP', 'LOG_KERN', 'LOG_LPR', 'LOG_MAIL', 'LOG_NEWS', 'LOG_AUTH', 'LOG_SYSLOG', 'LOG_USER', 'LOG_UUCP', 'LOG_LOCAL0', 'LOG_LOCAL1', 'LOG_LOCAL2', 'LOG_LOCAL3', 'LOG_LOCAL4', 'LOG_LOCAL5', 'LOG_LOCAL6', 'LOG_LOCAL7'] valid_facilities.extend(consts) raise TypeError(_('syslog facility must be one of: %s') % ', '.join("'%s'" % fac for fac in valid_facilities)) return facility
def set_vswitch_port_vsid(self, vsid, switch_port_name): port_alloc, found = self._get_switch_port_allocation(switch_port_name) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) vsid_settings = self._get_security_setting_data_from_port_alloc( port_alloc) if vsid_settings: if vsid_settings.VirtualSubnetId == vsid: # VSID already added, no need to readd it. return # Removing the feature because it cannot be modified # due to a wmi exception. self._remove_virt_feature(vsid_settings) # remove from cache. self._vsid_sds.pop(port_alloc.InstanceID, None) vsid_settings = self._create_default_setting_data( self._PORT_SECURITY_SET_DATA) vsid_settings.VirtualSubnetId = vsid self._add_virt_feature(port_alloc, vsid_settings)
def set_vswitch_port_vsid(self, vsid, switch_port_name): port_alloc, found = self._get_switch_port_allocation(switch_port_name) if not found: raise utils.HyperVException( msg=_('Port Allocation not found: %s') % switch_port_name) vsid_settings = self._get_security_setting_data_from_port_alloc( port_alloc) if vsid_settings: if vsid_settings.VirtualSubnetId == vsid: # VSID already added, no need to readd it. return # Removing the feature because it cannot be modified # due to a wmi exception. self._remove_virt_feature(vsid_settings) # remove from cache. self._vsid_sds.pop(port_alloc.InstanceID, None) vsid_settings = self._get_default_setting_data( self._PORT_SECURITY_SET_DATA) vsid_settings.VirtualSubnetId = vsid self._add_virt_feature(port_alloc, vsid_settings)
from oslo_config import cfg from oslo_log import log as logging from hyperv.common.i18n import _, _LI, _LW, _LE # noqa from hyperv.neutron import constants from hyperv.neutron import utilsv2 # Check needed for unit testing on Unix if sys.platform == 'win32': import wmi agent_opts = [ cfg.StrOpt('neutron_metadata_address', default='169.254.169.254', help=_('Specifies the address which will serve the metadata for' ' the instance.')), ] CONF = cfg.CONF CONF.register_opts(agent_opts, "AGENT") LOG = logging.getLogger(__name__) class NvgreUtils(object): _HYPERV_VIRT_ADAPTER = 'Hyper-V Virtual Ethernet Adapter' _IPV4_ADDRESS_FAMILY = 2 _WNV_BIND_NAME = 'Wnv' _TRANSLATE_NAT = 0 _TRANSLATE_ENCAP = 1
def _get_vswitch(self, vswitch_name): vswitch = self._conn.Msvm_VirtualSwitch(ElementName=vswitch_name) if not vswitch: raise HyperVException(msg=_('VSwitch not found: %s') % vswitch_name) return vswitch[0]
def enable_control_metrics(self, switch_port_name): raise NotImplementedError( _("Metrics collection is not supported on " "this version of Hyper-V"))
from oslo_config import cfg from oslo_log import log as logging import six from hyperv.common.i18n import _, _LE, _LI # noqa from hyperv.neutron import constants from hyperv.neutron import hyperv_agent_notifier from hyperv.neutron import nvgre_ops from hyperv.neutron import utils from hyperv.neutron import utilsfactory nvgre_opts = [ cfg.BoolOpt('enable_support', default=False, help=_('Enables Hyper-V NVGRE. ' 'Requires Windows Server 2012 or above.')), cfg.IntOpt('provider_vlan_id', default=0, help=_('Specifies the VLAN ID of the physical network, required' ' for setting the NVGRE Provider Address.')), cfg.StrOpt('provider_tunnel_ip', default=None, help=_('Specifies the tunnel IP which will be used and ' 'reported by this host for NVGRE networks.')), ] CONF = cfg.CONF CONF.register_opts(nvgre_opts, "NVGRE") LOG = logging.getLogger(__name__)
# # Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_config import cfg from hyperv.common.i18n import _ HYPERV_AGENT_OPTS = [ cfg.ListOpt('physical_network_vswitch_mappings', default=[], help=_('List of <physical_network>:<vswitch> ' 'where the physical networks can be expressed with ' 'wildcards, e.g.: ."*:external"')), cfg.StrOpt('local_network_vswitch', default='private', help=_('Private vswitch name used for local networks')), cfg.IntOpt('polling_interval', default=2, min=1, help=_("The number of seconds the agent will wait between " "polling for local device changes.")), cfg.IntOpt('worker_count', default=10, min=1, help=_("The number of worker threads allowed to run in " "parallel to process port binding.")), cfg.IntOpt('worker_retry',
from oslo.config import cfg from hyperv.common.i18n import _, _LW # noqa from hyperv.common import log as logging from hyperv.neutron import utils from hyperv.neutron import utilsv2 # Check needed for unit testing on Unix if sys.platform == 'win32': import wmi hyper_opts = [ cfg.BoolOpt('force_hyperv_utils_v1', default=False, help=_('Force V1 WMI utility classes')), ] CONF = cfg.CONF CONF.register_opts(hyper_opts, 'hyperv') LOG = logging.getLogger(__name__) def _get_windows_version(): return wmi.WMI(moniker='//./root/cimv2').Win32_OperatingSystem()[0].Version def _check_min_windows_version(major, minor, build=0): version_str = _get_windows_version() return map(int, version_str.split('.')) >= [major, minor, build]
import re import time from oslo_config import cfg from oslo_log import log as logging from hyperv.common.i18n import _, _LE, _LI # noqa from hyperv.neutron import constants from hyperv.neutron import hyperv_agent_notifier from hyperv.neutron import nvgre_ops from hyperv.neutron import utils from hyperv.neutron import utilsfactory nvgre_opts = [ cfg.BoolOpt( "enable_support", default=False, help=_("Enables Hyper-V NVGRE. " "Requires Windows Server 2012 or above.") ), cfg.IntOpt( "provider_vlan_id", default=0, help=_("Specifies the VLAN ID of the physical network, required" " for setting the NVGRE Provider Address."), ), cfg.StrOpt( "provider_tunnel_ip", default=None, help=_("Specifies the tunnel IP which will be used and " "reported by this host for NVGRE networks."), ), ] CONF = cfg.CONF CONF.register_opts(nvgre_opts, "NVGRE")
def enable_control_metrics(self, switch_port_name): raise NotImplementedError(_("Metrics collection is not supported on " "this version of Hyper-V"))
def _get_vnic_settings(self, vnic_name): vnic_settings = self._conn.Msvm_SyntheticEthernetPortSettingData( ElementName=vnic_name) if not vnic_settings: raise HyperVException(msg=_('Vnic not found: %s') % vnic_name) return vnic_settings[0]
# Unless required by applicable law or agreed to in writing, software # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the # License for the specific language governing permissions and limitations # under the License. from oslo_config import cfg from hyperv.common.i18n import _ HYPERV_AGENT_OPTS = [ cfg.ListOpt( 'physical_network_vswitch_mappings', default=[], help=_('List of <physical_network>:<vswitch> ' 'where the physical networks can be expressed with ' 'wildcards, e.g.: ."*:external"')), cfg.StrOpt( 'local_network_vswitch', default='private', help=_('Private vswitch name used for local networks')), cfg.IntOpt('polling_interval', default=2, help=_("The number of seconds the agent will wait between " "polling for local device changes.")), cfg.IntOpt('worker_count', default=10, help=_("The number of worker processes allowed to run in " "parallel to process port binding.")), cfg.IntOpt('worker_retry', default=3, help=_("The number of times worker process will retry " "port binding.")), cfg.BoolOpt('enable_metrics_collection',