Return true if the register command is disabled (for the given server.)
197909
def get_skipregister(self, location=None):
        
        if location is None:
            return self.skipregister or not self.defaults.register
        else:
            server = self.defaults.servers[location]
            if self.skipregister:
                return True
            elif server.register is not None:
                if not self.defaults.register and self.get_skipupload():
                    return True # prevent override
                return not server.register
            elif not self.defaults.register:
                return True
            return False
908089
def has_reg?(name, params = {})
      params = {
        test_for_true_false: true
      }.update(params)
      if params.key?(:enabled_features) || params.key?(:enabled_feature)
        return !!get_registers(params).include?(name)
      else
        params[:enabled_features] = :default
        return !!get_registers(params).include?(name)
      end
    end
834271
def _register_server(self, server, timeout=30):
        '''
        '''
        result = self._loop.run_until_complete(
            self._protocol.send_package(CPROTO_REQ_REGISTER_SERVER,
                                        data=server,
                                        timeout=timeout))
        return result
244332
protected function _isActionEnabled(ServerRequest $request) {
		$actions = $this->getConfig('actions');
		if (!$actions) {
			return true;
		}

		return in_array($request->getParam('action'), $actions, true);
	}
911482
def is_enabled(self, name):
        
        if self.services and name in self.services:
            return self.services[name]['config'] == 'enabled'
        return False
1321173
def enabled(name, **kwargs):
    '''
    
    '''
    if _service_is_upstart(name):
        return _upstart_is_enabled(name)
    else:
        if _service_is_sysv(name):
            return _sysv_is_enabled(name)
    return None
538794
async def disable(self, ctx, *, command: str):
        
        command = command.lower()

        if command in ('enable', 'disable'):
            return await self.bot.responses.failure(message='Cannot disable that command.')

        if command not in self.bot.commands:
            return await self.bot.responses.failure(message='Command "{}" was not found.'.format(command))

        guild_id = ctx.message.server.id
        cmds = self.config.get('commands', {})
        entries = cmds.get(guild_id, [])
        entries.append(command)
        cmds[guild_id] = entries
        await self.config.put('commands', cmds)
        await self.bot.responses.success(message='"%s" command disabled in this server.' % command)
22493
def enable_command(self, command: str) -> None:
        
        # If the commands is already enabled, then return
        if command not in self.disabled_commands:
            return

        help_func_name = HELP_FUNC_PREFIX + command

        # Restore the command and help functions to their original values
        dc = self.disabled_commands[command]
        setattr(self, self.cmd_func_name(command), dc.command_function)

        if dc.help_function is None:
            delattr(self, help_func_name)
        else:
            setattr(self, help_func_name, dc.help_function)

        # Remove the disabled command entry
        del self.disabled_commands[command]
652597
function() {
        switch(self.command) {          
            case constants.WHOIS:
                return (self.params[0][0] == 'A');
            case constants.PASSWORD:
                return true;
            case constants.NUMERICINFO:
            case constants.GENERALINFO: // client-to-server
                return (self.params.length < 2) || (self.params[0][0] == 'c');
            case constants.SERVERMESSAGE:
                return true;
            default:
                return false;
        }
    }
524801
def enable(iface):
    '''
    
    '''
    if is_enabled(iface):
        return True
    cmd = ['netsh', 'interface', 'set', 'interface',
           'name={0}'.format(iface),
           'admin=ENABLED']
    __salt__['cmd.run'](cmd, python_shell=False)
    return is_enabled(iface)
1036358
boolean processUnstable() {
        boolean change = !unstable;
        if (change) {  // Only once until the process is removed. A process is unstable until removed.
            unstable = true;
            HostControllerLogger.ROOT_LOGGER.managedServerUnstable(serverName);
        }
        return change;
    }
235269
public function hasEnabledInvitationRegistration()
    {
        if ($this->invitationRegistrationClass === false || !is_string($this->invitationRegistrationClass) || !class_exists($this->invitationRegistrationClass)) {
            return false;
        }
        return true;
    }
500642
def enable(self, cmd="enable-admin", pattern="ssword", re_flags=re.IGNORECASE):
        """"""
        return super(AlcatelSrosSSH, self).enable(
            cmd=cmd, pattern=pattern, re_flags=re_flags
        )
782015
def shutdown(host=None, port=None, db=None, password=None):
    '''
    
    '''
    server = _connect(host, port, db, password)
    try:
        # Return false if unable to ping server
        server.ping()
    except redis.ConnectionError:
        return False

    server.shutdown()
    try:
        # This should fail now if the server is shutdown, which we want
        server.ping()
    except redis.ConnectionError:
        return True
    return False
694238
def get_disabled():
    '''
    
    '''
    services = []
    for daemon, is_enabled in six.iteritems(_get_rc()):
        if not is_enabled:
            services.append(daemon)
    return sorted(set(get_all()) & set(services))
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)
687760
def enable():
    '''
    
    '''
    puppet = _Puppet()

    if os.path.isfile(puppet.disabled_lockfile):
        try:
            os.remove(puppet.disabled_lockfile)
        except (IOError, OSError) as exc:
            msg = 'Failed to enable: {0}'.format(exc)
            log.error(msg)
            raise CommandExecutionError(msg)
        else:
            return True
    return False