Locate the {@code ExecutorConfig} in local {@link #executorConfigCache} or find it from {@link NodeEngine#getConfig()} and
cache it locally.

@param name
@return
488778
private ExecutorConfig getOrFindExecutorConfig(String name) {
        ExecutorConfig cfg = executorConfigCache.get(name);
        if (cfg != null) {
            return cfg;
        } else {
            cfg = nodeEngine.getConfig().findExecutorConfig(name);
            ExecutorConfig executorConfig = executorConfigCache.putIfAbsent(name, cfg);
            return executorConfig == null ? cfg : executorConfig;
        }
    }
361385
private Object get(String name) {
        if (isEmbedded)
            return embeddedRAConfig == null ? null : embeddedRAConfig.get(name);
        else
            return config.get(name);
    }
585189
public static ExecutorService getSingleThreadExecutor(String name) {
        ExecutorService ste =
                new ThreadPoolExecutor(1, 1,
                        0L, TimeUnit.MILLISECONDS,
                        new LinkedBlockingQueue<Runnable>(),
                        CoreUtils.getThreadFactory(null, name, SMALL_STACK_SIZE, false, null));
        return ste;
    }
1216657
@Override
    public EventJournalConfig getEventJournalConfig(ObjectNamespace namespace) {
        String name = namespace.getObjectName();
        CacheConfig cacheConfig = getCacheService().getCacheConfig(name);
        if (cacheConfig == null) {
            throw new CacheNotExistsException("Cache " + name + " is already destroyed or not created yet, on "
                    + nodeEngine.getLocalMember());
        }
        String cacheSimpleName = cacheConfig.getName();
        EventJournalConfig config = nodeEngine.getConfig().findCacheEventJournalConfig(cacheSimpleName);
        if (config == null || !config.isEnabled()) {
            return null;
        }
        return config;
    }
1225445
public Configuration getConfiguration(String name) {
        Configuration[] values = getConfigurations(name);

        if (values == null) {
            return null;
        }

        return values[0];
    }
1152132
@RequestMapping(value = "configurations/{name}", method = RequestMethod.GET)
    public JIRAConfiguration getConfiguration(@PathVariable String name) {
        return jiraConfigurationService.getConfiguration(name);
    }
770499
public Configuration[] getConfigurations(String name) {
        ArrayList<Configuration> valuesList = new ArrayList<Configuration>();

        logger.info("Getting data for {}", name);

        PreparedStatement statement = null;
        ResultSet results = null;

        try (Connection sqlConnection = sqlService.getConnection()) {

            String queryString = "SELECT * FROM " + Constants.DB_TABLE_CONFIGURATION;
            if (name != null) {
                queryString += " WHERE " + Constants.DB_TABLE_CONFIGURATION_NAME + "=?";
            }

            statement = sqlConnection.prepareStatement(queryString);
            if (name != null) {
                statement.setString(1, name);
            }

            results = statement.executeQuery();
            while (results.next()) {
                Configuration config = new Configuration();
                config.setValue(results.getString(Constants.DB_TABLE_CONFIGURATION_VALUE));
                config.setKey(results.getString(Constants.DB_TABLE_CONFIGURATION_NAME));
                config.setId(results.getInt(Constants.GENERIC_ID));
                logger.info("the configValue is = {}", config.getValue());
                valuesList.add(config);
            }
        } catch (SQLException sqe) {
            logger.info("Exception in sql");
            sqe.printStackTrace();
        } finally {
            try {
                if (results != null) {
                    results.close();
                }
            } catch (Exception e) {
            }
            try {
                if (statement != null) {
                    statement.close();
                }
            } catch (Exception e) {
            }
        }

        if (valuesList.size() == 0) {
            return null;
        }

        return valuesList.toArray(new Configuration[0]);
    }
847934
public static List<Object> getList(String name){
        if(getConfiguration().containsKey(name)){
            return getConfiguration().getList(name);
        }
        return null;
    }
873777
public <T extends CacheSpec<K, V>> T name(String name) {
      this.name = name;
      return Cast.as(this);
   }
792203
public Connection getConnection(String name) throws ExecutionException {
        Connection connection = null;
        synchronized (connections) {
            if (connections.containsKey(name)) {
                connection = connections.get(name);
            } else {

                String msg = "The connection [" + name + "] does not exist";
                logger.error(msg);
                throw new ExecutionException(msg);
            }
        }
        return connection;
    }
720284
public Node getNode(String name) {
    Node n = hostnameToNodeMap.get(name);

    // it's ok if multiple threads try to resolve the same host at the same time
    // the assumption is that resolve() will return a canonical node object and
    // the put operation is therefore idempotent
    if (n == null) {
      n = resolveAndGetNode(name);
      hostnameToNodeMap.put(name, n);
      // Make an entry for the node at the max level in the cache
      nodesAtMaxLevel.add(
        getParentNode(n, NetworkTopology.DEFAULT_HOST_LEVEL - 1));
    }

    return n;
  }
447014
public static Cache getSyncCache(String name) {
		if (StrKit.isBlank(name) || !GlobalSyncRedis.caches.containsKey(name)) {
			return Redis.use();
		}
		return GlobalSyncRedis.caches.get(name);
	}
120842
@Read
    public Maybe<Map<String, Object>> getCache(@NotBlank @Selector String name) {
        try {
            final Cache<Object> cache = cacheManager.getCache(name);
            return Flowable.fromPublisher(cache.getCacheInfo())
                           .map(CacheInfo::get)
                           .singleElement();
        } catch (ConfigurationException e) {
            // no cache exists
            return Maybe.empty();
        }
    }
473149
public BeanInvoker getWriteInvoker(String name) {
        BeanInvoker invoker;
        if (writeInvokers.containsKey(name)) {
            invoker = writeInvokers.get(name);
        } else {
            invoker = getInvoker(HandleType.SET, name);
            writeInvokers.put(name, invoker);
        }
        return invoker;
    }
1229758
private void cacheMapping(final String name, final byte[] id) {
    addIdToCache(name, id);
    addNameToCache(id, name);
  }
1035045
public static <Key, Entry> CacheConfiguration<Key, Entry> getCacheConfiguration(String cacheName) {
        CacheConfiguration<Key, Entry> cacheCfg = new CacheConfiguration<>(cacheName);
        cacheCfg.setBackups(0);
        cacheCfg.setCacheMode(CacheMode.PARTITIONED);
        cacheCfg.setAtomicityMode(CacheAtomicityMode.ATOMIC);
        cacheCfg.setReadThrough(false);
        cacheCfg.setWriteThrough(false);
        cacheCfg.setMemoryMode(CacheMemoryMode.OFFHEAP_TIERED);
        cacheCfg.setEvictionPolicy(new LruEvictionPolicy<>(10000));
        cacheCfg.setSwapEnabled(true);
        cacheCfg.setOffHeapMaxMemory(5L * 1024L * 1024L * 1024L);
        return cacheCfg;
    }
283631
protected Template getTemplate(String name) {
    try {
      return configuration.getTemplate(name);
    } catch (IOException e) {
      throw new GenException(Message.DOMAGEN9001, e, e);
    }
  }