Hosts that are ignored by Betamax. Any connections made will be allowed to proceed normally and not be
intercepted.
420999
public Collection<String> getIgnoreHosts() {
        if (isIgnoreLocalhost()) {
            return new ImmutableSet.Builder<String>()
                    .addAll(ignoreHosts)
                    .addAll(Network.getLocalAddresses())
                    .build();
        } else {
            return ignoreHosts;
        }
    }
415739
def undeaf
      response = Network.post(['Conferences', self.conference_sid, 'Participant', self.call_sid], { :Deaf => false })
      Participant.new(response)
    end
841017
public void setProxyHostsBlackList(String[] hosts)
    {
        if (hosts == null || hosts.length == 0)
            _proxyHostsBlackList = null;
        else
        {
            _proxyHostsBlackList = new HashSet();
            for (int i = 0; i < hosts.length; i++)
                if (hosts[i] != null && hosts[i].trim().length() > 0)
                    _proxyHostsBlackList.add(hosts[i]);
        }
    }
993897
protected function isVisitorIpExcluded()
    {
        $excludedIps = $this->getAttributes('excluded_ips', 'global_excluded_ips');

        if (!empty($excludedIps)) {
            $ip = IP::fromBinaryIP($this->ip);
            if ($ip->isInRanges($excludedIps)) {
                Common::printDebug('Visitor IP ' . $ip->toString() . ' is excluded from being tracked');
                return true;
            }
        }

        return false;
    }
1079461
def _hosts_by_success(self, hosts=[]):
        
        hosts = hosts if hosts else self.hosts
        return sorted(hosts, key=lambda h: self._host_errors[h])
917696
def filter_unbound_ports(query):
    """"""
    # hack for pep8 E711: comparison to None should be
    # 'if cond is not None'
    none = None
    port_model = models_v2.Port
    binding_level_model = ml2_models.PortBindingLevel
    query = (query
             .join_if_necessary(port_model)
             .join_if_necessary(binding_level_model)
             .filter(
                 binding_level_model.host != '',
                 port_model.device_id != none,
                 port_model.network_id != none))
    return query
162742
def all_hosts(self):
        """"""
        return set(imap(common.clean_node, itertools.chain(
            self._doc.get('hosts', []),
            self._doc.get('passives', []),
            self._doc.get('arbiters', []))))
405495
def remove_exclusion(host_or_ip)
      asset = host_or_ip
      unless host_or_ip.respond_to?(:host) || host_or_ip.respond_to?(:from)
        # Attept to convert String to appropriate object.
        asset = HostOrIP.convert(host_or_ip)
      end
      @asset_exclusions = asset_exclusions.reject { |a| a.eql? asset }
    end
929299
def disable_host_notifications(self, host):
        
        if host.notifications_enabled:
            host.modified_attributes |= DICT_MODATTR["MODATTR_NOTIFICATIONS_ENABLED"].value
            host.notifications_enabled = False
            self.send_an_element(host.get_update_status_brok())
1336741
public boolean isHostProxyable(String host) {
        return getProxyHost() != null
                && getProxyPort() > 0
                && (nonProxyPattern == null || !nonProxyPattern.matcher(host)
                        .matches());
    }
650996
def failover_limitation(self):
        """"""
        if not self.reachable:
            return 'not reachable'
        if self.tags.get('nofailover', False):
            return 'not allowed to promote'
        if self.watchdog_failed:
            return 'not watchdog capable'
        return None
1207149
def get_slave_addrs(mgr_addr, N):
    '''
    '''
    return  [(HOST, p) for p in range(mgr_addr+1, mgr_addr+1+N)]
718713
def connectionMade(self):
        """"""
        self.endpoint = self.transport.getPeer()
        # get the reference to the Address object in NodeLeader so we can manipulate it properly.
        tmp_addr = Address(f"{self.endpoint.host}:{self.endpoint.port}")
        try:
            known_idx = self.leader.KNOWN_ADDRS.index(tmp_addr)
            self.address = self.leader.KNOWN_ADDRS[known_idx]
        except ValueError:
            # Not found.
            self.leader.AddKnownAddress(tmp_addr)
            self.address = tmp_addr

        self.address.address = "%s:%s" % (self.endpoint.host, self.endpoint.port)
        self.host = self.endpoint.host
        self.port = int(self.endpoint.port)
        self.leader.AddConnectedPeer(self)
        self.leader.RemoveFromQueue(self.address)
        self.leader.peers_connecting -= 1
        logger.debug(f"{self.address} connection established")
        if self.incoming_client:
            # start protocol
            self.SendVersion()
919794
public boolean isRemoteAccessAllowed(String pRemoteHost, String pRemoteAddr) {
        return restrictor.isRemoteAccessAllowed(pRemoteHost != null ?
                                                        new String[] { pRemoteHost, pRemoteAddr } :
                                                        new String[] { pRemoteAddr });
    }
354113
def disable_host_check(self, host):
        
        if host.active_checks_enabled:
            host.modified_attributes |= DICT_MODATTR["MODATTR_ACTIVE_CHECKS_ENABLED"].value
            host.disable_active_checks(self.daemon.checks)
            self.send_an_element(host.get_update_status_brok())
68633
def ssh_cleanup_known_hosts!(hosts=[host, public_ip])
      hosts = [hosts] unless hosts.respond_to? :each
      hosts.compact.each do |name|
        system_run "ssh-keygen -R %s" % name
      end
    end
635357
def stop_tracking_host(self):
        '''
            
        '''
        try:
            self.server.hosts.remove(self.client_address[0])
            if hasattr(self.server.module, 'on_shutdown'):
                self.server.module.on_shutdown(self.server.context, self.server.connection)
        except ValueError:
            pass