// disableOthers disables all other runtimes except for me.
188484
func disableOthers(me Manager, cr CommandRunner) error {
	// valid values returned by manager.Name()
	runtimes := []string{"containerd", "crio", "docker"}
	for _, name := range runtimes {
		r, err := New(Config{Type: name, Runner: cr})
		if err != nil {
			return fmt.Errorf("runtime(%s): %v", name, err)
		}

		// Don't disable myself.
		if r.Name() == me.Name() {
			continue
		}
		// runtime is already disabled, nothing to do.
		if !r.Active() {
			continue
		}
		if err = r.Disable(); err != nil {
			glog.Warningf("disable failed: %v", err)
		}
		// Validate that the runtime really is offline - and that Active & Disable are properly written.
		if r.Active() {
			return fmt.Errorf("%s is still active", r.Name())
		}
	}
	return nil
}
818823
func (c *Client) DisableUser(p *DisableUserParameter) (*User, error) {
	obj, err := c.Request("disableUser", convertParamToMap(p))
	if err != nil {
		return nil, err
	}
	return obj.(*User), err
}
38602
func DisableIRQs(irqs uint64) {
	const irqDisable1 = 0x21C / 4
	const irqDisable2 = 0x220 / 4
	intrMem[irqDisable1] = uint32(irqs)       // IRQ 0..31
	intrMem[irqDisable2] = uint32(irqs >> 32) // IRQ 32..63
}
248124
func (p *Partition) DisableCompactions() {
	p.mu.Lock()
	defer p.mu.Unlock()

	p.compactionsDisabled++
}
1188218
func (c *Client) DisablePlugin(opts DisablePluginOptions) error {
	path := "/plugins/" + opts.Name + "/disable"
	resp, err := c.do("POST", path, doOptions{context: opts.Context})
	defer resp.Body.Close()
	if err != nil {
		return err
	}
	resp.Body.Close()
	return nil
}
1107242
func (m *mapReact) Disable(r SenderDetachCloser) {
	var ok bool
	m.ro.RLock()
	_, ok = m.ma[r]
	m.ro.RUnlock()

	if !ok {
		return
	}

	m.ro.Lock()
	m.ma[r] = false
	m.ro.Unlock()
}
763695
func Disable() {
	disableStats()
	sampler = trace.NeverSample()
	if traceExporter != nil {
		trace.UnregisterExporter(traceExporter)
	}
	enabled = false
}
916752
func (s *Server) InstallDebuggingDisabledHandlers() {
	h := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		http.Error(w, "Debug endpoints are disabled.", http.StatusMethodNotAllowed)
	})

	paths := []string{
		"/run/", "/exec/", "/attach/", "/portForward/", "/containerLogs/",
		"/runningpods/", pprofBasePath, logsPath}
	for _, p := range paths {
		s.restfulCont.Handle(p, h)
	}
}
100896
func (s *UsergroupsService) Disable(usergroup string) *UsergroupsDisableCall {
	var call UsergroupsDisableCall
	call.service = s
	call.usergroup = usergroup
	return &call
}
1293217
func (m *BaseMechanism) Disable() {
	atomic.StoreInt64(&m.activated, 0)
	atomic.StoreInt64(&m.enabled, 0)
}
579209
func AllowOther() MountOption {
	return func(conf *mountConfig) error {
		if _, ok := conf.options["allow_root"]; ok {
			return ErrCannotCombineAllowOtherAndAllowRoot
		}
		conf.options["allow_other"] = ""
		return nil
	}
}
642685
func (c *ChaincodeLogger) IsEnabledFor(level LoggingLevel) bool {
	return c.logger.IsEnabledFor(logging.Level(level))
}
588050
func (v *version) LimitRanges() LimitRangeInformer {
	return &limitRangeInformer{factory: v.factory, namespace: v.namespace, tweakListOptions: v.tweakListOptions}
}
503
func (s *VanityNameServersService) DisableVanityNameServers(accountID string, domainIdentifier string) (*vanityNameServerResponse, error) {
	path := versioned(vanityNameServerPath(accountID, domainIdentifier))
	vanityNameServerResponse := &vanityNameServerResponse{}

	resp, err := s.client.delete(path, nil, nil)
	if err != nil {
		return nil, err
	}

	vanityNameServerResponse.HttpResponse = resp
	return vanityNameServerResponse, nil
}
1221531
func (s *UtteranceData) SetDistinctUsers(v int64) *UtteranceData {
	s.DistinctUsers = &v
	return s
}
558050
func (api *Client) DisableUserGroup(userGroup string) (UserGroup, error) {
	return api.DisableUserGroupContext(context.Background(), userGroup)
}
736293
func (c *UsergroupsUsersListCall) IncludeDisabled(includeDisabled bool) *UsergroupsUsersListCall {
	c.includeDisabled = includeDisabled
	return c
}