Function waitPuppetCatalogToBeApplied
        Wait for puppet catalog to be applied

        @param key: The host name or ID
        @return RETURN: None
547932
def waitPuppetCatalogToBeApplied(self, key, sleepTime=5):
        
        # Wait for puppet catalog to be applied
        loop_stop = False
        while not loop_stop:
            status = self[key].getStatus()
            if status == 'No Changes' or status == 'Active':
                self.__printProgression__(True,
                                          key + ' creation: provisioning OK')
                loop_stop = True
            elif status == 'Error':
                self.__printProgression__(False,
                                          key + ' creation: Error - '
                                          'Error during provisioning')
                loop_stop = True
                return False
            else:
                self.__printProgression__('In progress',
                                          key + ' creation: provisioning ({})'
                                          .format(status),
                                          eol='\r')
            time.sleep(sleepTime)
368794
def wait
      perform_operation do |redis|
        redis.blpop(wait_key, MAX_OP_WAIT_TIME - 3)
        redis.del(wait_key)
      end
    end
914861
def get(self, key):
        

        if not key in self._actions:
            return None
        if not key in self._cache:
            self._cache[key] = self._actions[key]()

        return self._cache[key]
1361338
@Override
  public ApiType getByKey(String key) {
    lock.lock();
    try {
      return this.items.get(key);
    } finally {
      lock.unlock();
    }
  }
1011156
async def wait(self, need_pts=False) -> dict:
        
        if not self.base_url:
            await self._get_long_poll_server(need_pts)

        params = {
            'ts': self.ts,
            'key': self.key,
        }
        params.update(self.base_params)
        # invalid mimetype from server
        code, response = await self.api._session.driver.get_text(
            self.base_url, params,
            timeout=2 * self.base_params['wait']
        )

        if code == 403:
            raise VkLongPollError(403, 'smth weth wrong', self.base_url + '/', params)

        response = json.loads(response)
        failed = response.get('failed')

        if not failed:
            self.ts = response['ts']
            return response

        if failed == 1:
            self.ts = response['ts']
        elif failed == 4:
            raise VkLongPollError(
                4,
                'An invalid version number was passed in the version parameter',
                self.base_url + '/',
                params
            )
        else:
            self.base_url = None

        return await self.wait()
854527
public void getActivation(String key) {
        ClientResource resource = new ClientResource(Route.ACTIVATE.url());
        Reference ref = resource.getReference();

        Map<String, Object> param = new HashMap<>();
        param.put("activation_key", key);

        Route.addParameters(ref, param);

        resource.get();
    }
722905
def request(key, method)
      instance = ::Puppet::Indirector::Indirection.instance(:resource_type)
      indirection_name = 'test'
      @request = ::Puppet::Indirector::Request.new(indirection_name, method, key, instance)
      @request.environment = puppet_environment
      @request
    end
449293
def is_ready(self, key):
        """"""
        if self.pending_callbacks is None or key not in self.pending_callbacks:
            raise UnknownKeyError("key %r is not pending" % (key,))
        return key in self.results
703139
public EtcdResponse get(String key) throws EtcdException {
		UriComponentsBuilder builder = UriComponentsBuilder.fromUriString(KEYSPACE);
		builder.pathSegment(key);

		return execute(builder, HttpMethod.GET, null, EtcdResponse.class);
	}
188587
public Try<UploadResult, Throwable> putSync(String key, Object value) {
        return put(key, value).map(FluentFunctions.ofChecked(i -> i.waitForUploadResult()));
    }
823133
def wait(hotkey=None, suppress=False, trigger_on_release=False):
    
    if hotkey:
        lock = _Event()
        remove = add_hotkey(hotkey, lambda: lock.set(), suppress=suppress, trigger_on_release=trigger_on_release)
        lock.wait()
        remove_hotkey(remove)
    else:
        while True:
            _time.sleep(1e6)
366921
private static boolean isApplicationHeader(String key) {
    // Don't allow HTTP/2 pseudo headers or content-type to be added by the application.
    return (!key.startsWith(":")
            && !CONTENT_TYPE_KEY.name().equalsIgnoreCase(key))
            && !USER_AGENT_KEY.name().equalsIgnoreCase(key);
  }
921107
protected Queue<AsyncResourceRequest<V>> getRequestQueueForExistingKey(K key) {
        Queue<AsyncResourceRequest<V>> requestQueue = requestQueueMap.get(key);
        return requestQueue;
    }
304188
@SuppressWarnings("unchecked")
	@Override
	public <V> V get(String key) {
		V returnValue = null;
		try{
			returnValue = (V) _jedisClusterClient.get(key);
		}catch (Exception ex) {
			_logger.error("Exception in cache service: {} ", ex.getMessage());
		}
		return returnValue;
	}
1122649
public T get(String key) {
        SoftReference<T> ref = cacheMap.get(key);
        if (ref != null) {
            if (ref.get() == null) {
                logger.debug("Cached item was cleared: " + key);
            }
            return ref.get(); //maybe still be null
        }

        return null;
    }
1245026
@ManagedOperation
    public V get(K key) {

        // 1. Try the L1 cache first
        if(l1_cache != null) {
            V val=l1_cache.get(key);
            if(val != null) {
                if(log.isTraceEnabled())
                    log.trace("returned value " + val + " for " + key + " from L1 cache");
                return val;
            }
        }

        // 2. Try the local cache
        Cache.Value<Value<V>> val=l2_cache.getEntry(key);
        Value<V> tmp;
        if(val != null) {
            tmp=val.getValue();
            if(tmp !=null) {
                V real_value=tmp.getVal();
                if(real_value != null && l1_cache != null && val.getTimeout() >= 0)
                    l1_cache.put(key, real_value, val.getTimeout());
                return tmp.getVal();
            }
        }

        // 3. Execute a cluster wide GET
        try {
            RspList<Object> rsps=disp.callRemoteMethods(null,
                                                new MethodCall(GET, key),
                                                new RequestOptions(ResponseMode.GET_ALL, call_timeout));
            for(Rsp rsp: rsps.values()) {
                Object obj=rsp.getValue();
                if(obj == null || obj instanceof Throwable)
                    continue;
                val=(Cache.Value<Value<V>>)rsp.getValue();
                if(val != null) {
                    tmp=val.getValue();
                    if(tmp != null) {
                        V real_value=tmp.getVal();
                        if(real_value != null && l1_cache != null && val.getTimeout() >= 0)
                            l1_cache.put(key, real_value, val.getTimeout());
                        return real_value;
                    }
                }
            }
            return null;
        }
        catch(Throwable t) {
            if(log.isWarnEnabled())
                log.warn("get() failed", t);
            return null;
        }
    }
959334
function(apiKey) {
  return function(path, data, done) {
    var url = apiBase + path + '?' + querystring.stringify(_.extend({ 'key': apiKey }, data));
    request.get(url, globalResponseHandler({ url: url }, done));
  };
}