Get the firewall policy for the named host.

The policy is constructed from the policies defined by any groups of
which the host is a member and the hosts own policy.

@param string $name Name of a Host.

@return array
192273
public function getPolicyByHostname($name)
    {
        if (! $this->inventory->hasHost($name)) {
            return array();
        }

        $policy = array();
        $host = $this->inventory->getHost($name);

        foreach ($this->inventory->getHostGroupsByHost($host) as $group) {
            $policy = array_replace_recursive($policy, $group->getFirewallPolicy());
        }

        return array_replace_recursive($policy, $host->getFirewallPolicy());
    }
919171
public function &getBlocksByName($name)
    {
        if (!isset($this->namedBlocks[$name])) {
            $this->namedBlocks[$name] = [];
        }

        return $this->namedBlocks[$name];
    }
1120833
protected function getConfigure(string $name): ?array
    {
        if (isset($this->config[$name])) {
            return $this->config[$name];
        }

        if (!isset($this->abstractAlias[$name])) {
            return null;
        }

        foreach ($this->abstractAlias[$name] as $alias) {
            if (isset($this->config[$alias])) {
                return $this->config[$alias];
            }
        }

        return null;
    }
1304260
public static function GetAuthCookieOptions ($name = self::DEFAULT_CONNECTION_NAME) {
		if (!isset(static::$_defaultCookieOptions[$name])) {
			static::SetAuthCookieOptions([
				'algorithm'				=> static::DEFAULT_HASH_ALGORITHM,
				'realm'					=> $_SERVER['SERVER_NAME'],
				'qop'					=> 'auth',
				'client_key'			=> null,
				'client_salt'			=> null,
				'server_key'			=> null,
				'server_salt'			=> null,
				'stretcher'				=> null,	//ex) [3, 1, 4],
				'separator_length'		=> 8,
				'valid_alter_lv'		=> static::VALID_ALTER_LV_LAZY,
				'cookie_save_dir'		=> sys_get_temp_dir(),
				'cookie_name_prefix'	=> 'cookie_auth_',
				'cookie_name_safix'		=> '',
				'cookie_expire'			=> 86400,
				'cookie_path'			=> '/',
				'cookie_domain'			=> null,
				'cookie_secure'			=> true,
				'cookie_httponly'		=> true,
				'divisor'				=> 1,
				'probability'			=> 512,
				'password_callback'		=> null,	// IF function ($user_name);
				'auth_impact_callback'	=> function ($on_storage_password, $user_name, $password) {
					return $on_storage_password === $password;
				},
			], $name);
		}
		return static::$_defaultCookieOptions[$name];
	}
1239836
public function getHeaderAsArray(string $name) : array
    {
        $name = strtolower($name);

        return isset($this->headers[$name]) ? $this->headers[$name] : [];
    }
202730
public function getMapping($name)
    {
        if ($mappings = $this->getMappings()) {
            
            if (isset($mappings[$name])) {
                return $mappings[$name];
            }
            
        }
    }
125612
public function getClient($name)
    {
        if (!isset($this->serverArray[$name])) {
            $name   = $this->defaultName;
        }

        if (isset($this->clientArray[$name])) {
            try {
                $this->clientArray[$name]->ping();
            } catch (\RedisException $ex) {
                $this->clientArray[$name] = $this->createClient($this->serverArray[$name]);
            }
            return $this->clientArray[$name];
        }

        $this->clientArray[$name] = $this->createClient($this->serverArray[$name]);
        return $this->clientArray[$name];
    }
44321
public function getProfile($name){
        if($this->loadProfiles != 'ALL' && !in_array($name, $this->loadProfiles)){
            $this->connection->select('id, name, join, error_redirect, error_forward');
            $this->connection->from($this->tableProfile);
            $this->connection->where('name = :name', array('name' => $name));
            $profile= $this->connection->get()->fetch(\PDO::FETCH_ASSOC);
            
            $this->connection->select('m.name');
            $this->connection->from($this->tableModulePermit . ' p');
            $this->connection->join($this->tableModule . ' m', 'p.moduleId = m.id');
            $this->connection->where('p.profileId = :id', array('id' => $profile['id']));
            $rta= $this->connection->get();
            $permitModules= array();
            while($module= $rta->fetch()){
                $permitModules[]= $module[0]; 
            }
            
            $this->connection->select('m.name');
            $this->connection->from($this->tableModuleDeny . ' p');
            $this->connection->join($this->tableModule . ' m', 'p.moduleId = m.id');
            $this->connection->where('p.profileId = :id', array('id' => $profile['id']));
            $rta= $this->connection->get();
            $denyModules= array();
            while($module= $rta->fetch()){
                $denyModules[]= $module[0]; 
            }
            
            $this->profiles[$name]= array('permit' => $permitModules, 'deny' => $denyModules, 'error-redirect' => $profile['error_redirect'], 'error-forward' => $profile['error_forward']);
            $this->loadProfiles[]= $name;
        }
        return $this->profiles[$name];
    }
124185
public function getHeader($name)
    {
        $key = strtolower($name);

        if (isset($this->responseHeader[$key])) {
            if (!isset($this->responseHeader[$key]['name']) &&
                 is_array($this->responseHeader[$key])) {
                $values = array();

                foreach ($this->responseHeader[$key] as $header) {
                    $values[] = $header['value'];
                }

                return $values;
            } else {
                return $this->responseHeader[$key]['value'];
            }
        }

        return;
    }
348976
public static function get($name)
    {
        if (!isset(self::$connections[$name])) {
            throw new Exception(sprintf('Connection "%s" does not exist.', $name));
        }

        return self::$connections[$name];
    }
1169501
public function getArrayOf(string $name) : array
    {
        $array = $this->content->hasArrayOf($name) ? $this->content->getArrayOf($name) : [];

        foreach ($array as $key => $contentGroup) {
            $array[$key] = new self($this->config, $contentGroup);
        }

        return $array;
    }
604432
public function get($name)
    {
        return isset($this->rules[$name]) ? $this->rules[$name] : null;
    }
1340216
public function getConnection($name)
    {
        if (!$this->connectionSettings->has($name)) {
            throw new BadArgumentException('Connection with name ":name" not defined in configuration file ":file"', [
                'name' => $name, 'file' => ServiceLocator::instance()->getConfiguration()->getIdentity(),
            ]);
        }
        
        if (!static::$connections->has($name)) {
            static::$connections->set($name, new Connection($this->connectionSettings->get($name)));
        }
        
        return static::$connections[$name];
    }
1174875
private function getHeader($name)
    {
        if (isset($this->headers[$name])) {
            return $this->headers[$name];
        }
        return false;
    }
401201
public function usersAction($name)
    {
        $server = $this->ldap->get($name);
        $user = isset($server['user']) ? $server['user'] : null;
        $password = isset($server['password']) ? $server['password'] : null;

        if ($this->ldap->connect($server, $user, $password)) {
            $classes = $this->ldap->getClasses($server);
            $users = $this->ldap->getUsers($server);
            $this->ldap->close();

            return [
                'server' => $server,
                'users' => $users,
                'usersJSON' => json_encode($users),
                'classes' => $classes,
            ];
        }

        return ['error' => true];
    }
640523
public function getHeader($name)
    {
        $headerSet = $this->getSwiftMessage()->getHeaders();
        if (!$headerSet->has($name)) {
            return [];
        }

        $headers = [];
        foreach ($headerSet->getAll($name) as $header) {
            $headers[] = $header->getValue();
        }
        return $headers;
    }
567776
public function getForConnection($name = null)
    {
        $connection = $this->registry->getConnection($name);

        return $this->factory->make($connection, $name);
    }