:class:`~zhmcclient.VirtualSwitchManager`: Access to the
        :term:`Virtual Switches <Virtual Switch>` in this CPC.
6103
def virtual_switches(self):
        
        # We do here some lazy loading.
        if not self._virtual_switches:
            self._virtual_switches = VirtualSwitchManager(self)
        return self._virtual_switches
1302835
def _build_credentials(self, nexus_switches):
        
        credentials = {}
        for switch_ip, attrs in nexus_switches.items():
            credentials[switch_ip] = (
                attrs[const.USERNAME], attrs[const.PASSWORD],
                attrs[const.HTTPS_VERIFY], attrs[const.HTTPS_CERT],
                None)
            if not attrs[const.HTTPS_VERIFY]:
                LOG.warning("HTTPS Certificate verification is "
                            "disabled. Your connection to Nexus "
                            "Switch %(ip)s is insecure.",
                            {'ip': switch_ip})
        return credentials
880784
def get_provider(cls, scm_name: str, conf) -> SourceControl:
        
        for entry_point in pkg_resources.iter_entry_points('yabt.scm',
                                                           scm_name):
            entry_point.load()
            logger.debug('Loaded SCM provider {0.name} from {0.module_name} '
                         '(dist {0.dist})', entry_point)
        logger.debug('Loaded {} SCM providers', len(cls.providers))
        if scm_name not in cls.providers:
            raise KeyError('Unknown SCM identifier {}'.format(scm_name))
        return cls.providers[scm_name](conf)
703931
def change_autocommit_mode(self, switch):
        
        parsed_switch = switch.strip().lower()
        if not parsed_switch in ['true', 'false']:
            self.send_response(
                self.iopub_socket, 'stream', {
                    'name': 'stderr',
                    'text': 'autocommit must be true or false.\n\n'
                }
            )

        switch_bool = (parsed_switch == 'true')
        committed = self.switch_autocommit(switch_bool)
        message = (
            'committed current transaction & ' if committed else '' +
            'switched autocommit mode to ' +
            str(self._autocommit)
        )
        self.send_response(
            self.iopub_socket, 'stream', {
                'name': 'stderr',
                'text': message,
            }
        )
904098
def _get_switches(self, profile):
        """"""
        switchports = self._get_switchports(profile)
        switches = set([switchport[0] for switchport in switchports])
        return switches
480066
def register_on_session_state_changed(self, callback):
        
        event_type = library.VBoxEventType.on_session_state_changed
        return self.event_source.register_callback(callback, event_type)
958059
def GetTypeManager(self):
      
      dynTypeMgr = None
      if self.hostSystem:
         try:
            dynTypeMgr = self.hostSystem.RetrieveDynamicTypeManager()
         except vmodl.fault.MethodNotFound as err:
            pass

      if not dynTypeMgr:
         # Older host not support RetrieveDynamicTypeManager
         cmdlineTypesMoId = "ha-dynamic-type-manager"
         dynTypeMgr = vmodl.reflect.DynamicTypeManager(cmdlineTypesMoId,
                                                       self.stub)
      return dynTypeMgr
128756
public static boolean getSwitch(StringBuffer interfaceConfig, StringBuffer methodConfig){
        methodConfig.append(".circuit.break");
        interfaceConfig.append(".circuit.break");
        //从dubbo.properties的配置中获取
        String switchConfig = ConfigUtils.getProperty(methodConfig.toString(), ConfigUtils.getProperty(interfaceConfig.toString(), ConfigUtils.getProperty("dubbo.reference.circuit.break", "false")));
        return Boolean.parseBoolean(switchConfig);
    }
1250037
def virtual_functions(self):
        
        # We do here some lazy loading.
        if not self._virtual_functions:
            self._virtual_functions = VirtualFunctionManager(self)
        return self._virtual_functions
589869
@Handler(priority = 1000)
    public void onProtocolSwitchAccepted(
            ProtocolSwitchAccepted event, IOSubchannel channel) {
        event.requestEvent().associated(Session.class)
            .ifPresent(session -> {
                channel.setAssociated(Session.class, session);
            });
    }
370872
private void sawSwitch(int pc) {
        int[] offsets = getSwitchOffsets();
        List<Integer> targets = new ArrayList<>(offsets.length);
        for (int offset : offsets) {
            targets.add(Integer.valueOf(offset + pc));
        }
        Integer defOffset = Integer.valueOf(getDefaultSwitchOffset() + pc);
        if (!targets.contains(defOffset)) {
            targets.add(defOffset);
        }
        Collections.sort(targets);

        Integer lastTarget = targets.get(0);
        for (int i = 1; i < targets.size(); i++) {
            Integer nextTarget = targets.get(i);
            ScopeBlock sb = new ScopeBlock(lastTarget.intValue(), nextTarget.intValue());
            sb.setCase();
            rootScopeBlock.addChild(sb);
            lastTarget = nextTarget;
        }
        for (Integer target : targets) {
            switchTargets.set(target.intValue());
        }
    }
819189
def _switch_defined(self, switch_ip):
        """"""
        switch = cfg.CONF.ml2_cisco.nexus_switches.get(switch_ip)
        if switch and switch.username and switch.password:
            return True
        else:
            return False
770036
def guest_nic_uncouple_from_vswitch(self, userid, nic_vdev,
                                        active=False):
        
        self._networkops.uncouple_nic_from_vswitch(userid, nic_vdev,
                                                   active=active)
370273
def bridged_interface_object
      VirtualBox::Global.global.host.network_interfaces.find do |ni|
        ni.name == bridged_interface
      end
    end
1318061
public FacesConfigFlowDefinitionSwitchType<FacesConfigFlowDefinitionType<T>> getOrCreateSwitch()
   {
      List<Node> nodeList = childNode.get("switch");
      if (nodeList != null &&  nodeList.size() > 0)
      {
         return new FacesConfigFlowDefinitionSwitchTypeImpl<FacesConfigFlowDefinitionType<T>>(this, "switch", childNode, nodeList.get(0));
      }
      return createSwitch();
   }
505271
def daemon_mode(self, args, options):
        
        cws = ControlWebSocket(self, args, options)
        cws.start()
        if 'cmdsock' in args and args['cmdsock']:
            lcs = LocalControlSocket(self, args, options)
            lcs.start()
            lcs.join()
        cws.join()
904202
public Manager getObject() throws Exception {
		Manager manager;
		if (singleton) {
			manager = SimonManager.manager();
		} else {
			manager = new SwitchingManager();
		}
		registerCallbacks(manager);
		configureEnabled(manager);
		return manager;
	}