AuthenticationType::disable
Disable an authentication type.
545326
public function disable()
    {
        if ($this->getAuthenticationTypeID() == 1) {
            throw new Exception(t('The core concrete5 authentication cannot be disabled.'));
        }
        $db = Loader::db();
        $db->Execute(
           'UPDATE AuthenticationTypes SET authTypeIsEnabled=0 WHERE AuthTypeID=?',
           [$this->getAuthenticationTypeID()]);
    }
876780
def disable_requiretty_on_sudoers(log=False):
    
    if log:
        bookshelf2.logging_helpers.log_green(
            'disabling requiretty on sudo calls')

    comment_line('/etc/sudoers',
                 '^Defaults.*requiretty', use_sudo=True)
    return True
928004
def validate_credential_type!
      credentials.each do |credential, value|
        next if value.nil?
        fail(Uber::Error::ConfigurationError.new("Invalid #{credential} specified: #{value.inspect} must be a string or symbol.")) unless value.is_a?(String) || value.is_a?(Symbol)
      end
    end
126088
public function disableLoggingFor($exceptionType): void
	{
		$this->disableLoggingFor = array_unique(array_merge($this->disableLoggingFor, (array) $exceptionType));
	}
1006731
def disable_component(self, component):
        
        if not isinstance(component, type):
            component = component.__class__
        self.enabled[component] = False
        self.components[component] = None
370314
def disable(iface):
    '''
    
    '''
    if is_disabled(iface):
        return True
    cmd = ['netsh', 'interface', 'set', 'interface',
           'name={0}'.format(iface),
           'admin=DISABLED']
    __salt__['cmd.run'](cmd, python_shell=False)
    return is_disabled(iface)
134494
def disable(thing = false)
      instrument(:disable) do |payload|
        adapter.add self

        gate = gate_for(thing)
        wrapped_thing = gate.wrap(thing)
        payload[:gate_name] = gate.name
        payload[:thing] = wrapped_thing

        adapter.disable self, gate, wrapped_thing
      end
    end
1239427
def disable_csrf_protection():
    
    if not HAS_PLONE_PROTECT:
        logger.warn(
            "Can not disable CSRF protection – please install plone.protect"
        )
        return False
    request = get_request()
    interface.alsoProvides(request, IDisableCSRFProtection)
    return True
647244
def disable():
    
    Benchmark.enable = False
    ComparisonBenchmark.enable = False
    BenchmarkedFunction.enable = False
    BenchmarkedClass.enable = False
1000396
public static boolean isAuthenticationEnabled(AlluxioConfiguration conf) {
    return !conf.getEnum(PropertyKey.SECURITY_AUTHENTICATION_TYPE, AuthType.class)
        .equals(AuthType.NOSASL);
  }
1228788
public void disable() {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
            Tr.debug(this, tc, "disable chain " + this);
        }
        enabled = false;
    }
148275
def validate_auth_type(self):
        

        for handler in HANDLERS:
            handler_type = handler.split(".")[-2]
            
            if handler_type == self.auth_type:
                self.handler_name = handler
                
                return
        
        self.handler_name = None
231880
def disable(config, tags, accounts, master, debug,
            suspend, disable_detector, delete_detector, dissociate, region):
    """"""
    accounts_config, master_info, executor = guardian_init(
        config, debug, master, accounts, tags)

    if sum(map(int, (suspend, disable_detector, dissociate))) != 1:
        raise ValueError((
            "One and only of suspend, disable-detector, dissociate"
            "can be specified."))

    master_session = get_session(
        master_info['role'], 'c7n-guardian',
        master_info.get('profile'), region)
    master_client = master_session.client('guardduty')
    detector_id = get_or_create_detector_id(master_client)

    if suspend:
        unprocessed = master_client.stop_monitoring_members(
            DetectorId=detector_id,
            AccountIds=[a['account_id'] for a in accounts_config['accounts']]
        ).get('UnprocessedAccounts', ())

        if unprocessed:
            log.warning(
                "Following accounts where unprocessed\n %s",
                format_event(unprocessed))
        log.info("Stopped monitoring %d accounts in master",
                 len(accounts_config['accounts']))
        return

    if dissociate:
        master_client.disassociate_members(
            DetectorId=detector_id,
            AccountIds=[a['account_id'] for a in accounts_config['accounts']])

    # Seems like there's a couple of ways to disable an account
    # delete the detector (member), disable the detector (master or member),
    # or disassociate members, or from member disassociate from master.
    for a in accounts_config['accounts']:
        member_session = get_session(
            a['role'], 'c7n-guardian',
            a.get('profile'), region)

        member_client = member_session.client('guardduty')
        m_detector_id = get_or_create_detector_id(member_client)
        if disable_detector:
            member_client.update_detector(
                DetectorId=m_detector_id, Enable=False)
            log.info("Disabled detector in account:%s", a['name'])
        if dissociate:
            try:
                log.info("Disassociated member account:%s", a['name'])
                result = member_client.disassociate_from_master_account(
                    DetectorId=m_detector_id)
                log.info("Result %s", format_event(result))
            except ClientError as e:
                if e.response['Error']['Code'] == 'InvalidInputException':
                    continue
        if delete_detector:
            member_client.delete_detector(DetectorId=m_detector_id)
            log.info("Deleted detector in account:%s", a['name'])
1330737
function disallowNodeType(type) {

  return function() {

    function check(node, reporter) {

      if (is(node, type)) {
        reporter.report(node.id, 'Element has disallowed type <' + type + '>');
      }
    }

    return {
      check
    };

  };

}
1336166
public void disableCompass() {
        mIsCompassEnabled = false;

        if (mOrientationProvider != null) {
            mOrientationProvider.stopOrientationProvider();
        }

        // Reset values
        mAzimuth = Float.NaN;

        // Update the screen to see changes take effect
        if (mMapView != null) {
            this.invalidateCompass();
        }
    }
866988
def disable(self):
        
        self.engine.data.update(dns_relay_interface=[])
        self.engine.data.pop('dns_relay_profile_ref', None)
949243
func (s *DeleteUserInput) SetAuthenticationType(v string) *DeleteUserInput {
	s.AuthenticationType = &v
	return s
}