Enables or disables CDN access for the specified container, and
        optionally sets the TTL for the container when enabling access.
345251
def _set_cdn_access(self, container, public, ttl=None):
        
        headers = {"X-Cdn-Enabled": "%s" % public}
        if public and ttl:
            headers["X-Ttl"] = ttl
        self.api.cdn_request("/%s" % utils.get_name(container), method="PUT",
                headers=headers)
427344
public StoreAsBinaryConfigurationBuilder enable() {
      attributes.attribute(ENABLED).set(true);
      getBuilder().memory().storageType(StorageType.BINARY);
      return this;
   }
233643
@Deprecated
  public final NettyChannelBuilder enableKeepAlive(boolean enable, long keepAliveTime,
      TimeUnit delayUnit, long keepAliveTimeout, TimeUnit timeoutUnit) {
    if (enable) {
      return keepAliveTime(keepAliveTime, delayUnit)
          .keepAliveTimeout(keepAliveTimeout, timeoutUnit);
    }
    return keepAliveTime(KEEPALIVE_TIME_NANOS_DISABLED, TimeUnit.NANOSECONDS);
  }
1242013
public void enableTimeToLive(StateTtlConfig ttlConfig) {
		Preconditions.checkNotNull(ttlConfig);
		Preconditions.checkArgument(
			ttlConfig.getUpdateType() != StateTtlConfig.UpdateType.Disabled &&
				queryableStateName == null,
			"Queryable state is currently not supported with TTL");
		this.ttlConfig = ttlConfig;
	}
1046225
function () {
    var options = { publicAccessLevel: BlobUtilities.BlobContainerPublicAccessType.CONTAINER };
    blobService.setContainerAcl(container, signedIdentifiers, options, function(error) {
      if (error) {
        console.log(error);
      } else {
        console.log('Uploaded the permissions for the container ' + container);
        callback();
      }
    });
  }
1199623
public function setConsumerAccessTokenTtl ( $token, $token_ttl )
	{
		if ($token_ttl <= 0)
		{
			// Immediate delete when the token is past its ttl
			$this->deleteConsumerAccessToken($token, 0, true);
		}
		else
		{
			// Set maximum time to live for this token
			$this->query('
						UPDATE oauth_server_token
						SET ost_token_ttl = DATE_ADD(NOW(), INTERVAL %d SECOND)
						WHERE ost_token 	 = \'%s\'
						  AND ost_token_type = \'access\'
						', $token_ttl, $token);
		}
	}
1212752
private boolean ensure2dLayout(IAtomContainer container) throws CDKException {
        if (!GeometryUtil.has2DCoordinates(container)) {
            StructureDiagramGenerator sdg = new StructureDiagramGenerator();
            sdg.generateCoordinates(container);
            return true;
        }
        return false;
    }
631124
def set_idle_ttl(cls, pid, ttl):
        
        with cls._lock:
            cls._ensure_pool_exists(pid)
            cls._pools[pid].set_idle_ttl(ttl)
210351
def container_cdn_command(self, url, container, container_object,
                              cdn_headers):
        

        headers, container_uri = self._return_base_data(
            url=url,
            container=container,
            container_object=container_object,
            object_headers=cdn_headers
        )

        if self.job_args.get('purge'):
            return self._deleter(
                uri=container_uri,
                headers=headers
            )
        else:
            return self._header_poster(
                uri=container_uri,
                headers=headers
            )
169155
public void setSSLPort() throws InstallationFailedException {
        Element httpsConnector =
                (Element) getDocument()
                        .selectSingleNode(HTTPS_CONNECTOR_XPATH);
        if (options.getBooleanValue(InstallOptions.SSL_AVAILABLE, true)) {
            if (httpsConnector == null) {
                Element service =
                        (Element) getDocument()
                                .selectSingleNode("/Server/Service[@name='Catalina']");
                httpsConnector = service.addElement("Connector");
                httpsConnector.addAttribute("maxThreads", "150");
                httpsConnector.addAttribute("minSpareThreads", "25");
                httpsConnector.addAttribute("maxSpareThreads", "75");
                httpsConnector.addAttribute("disableUploadTimeout", "true");
                httpsConnector.addAttribute("acceptCount", "100");
                httpsConnector.addAttribute("debug", "0");
                httpsConnector.addAttribute("scheme", "https");
                httpsConnector.addAttribute("secure", "true");
                httpsConnector.addAttribute("clientAuth", "false");
                httpsConnector.addAttribute("sslProtocol", "TLS");
            }
            httpsConnector.addAttribute("port", options
                    .getValue(InstallOptions.TOMCAT_SSL_PORT));
            httpsConnector.addAttribute("enableLookups", "true"); // supports client dns/fqdn in xacml authz policies

            String keystore = options.getValue(InstallOptions.KEYSTORE_FILE);
            if (keystore.equals(InstallOptions.INCLUDED)) {
                keystore = KEYSTORE_LOCATION;
            }

            addAttribute(httpsConnector,
                         "keystoreFile",
                         keystore,
                         InstallOptions.DEFAULT);
            addAttribute(httpsConnector,
                         "keystorePass",
                         options.getValue(InstallOptions.KEYSTORE_PASSWORD),
                         KEYSTORE_PASSWORD_DEFAULT);
            addAttribute(httpsConnector,
                         "keystoreType",
                         options.getValue(InstallOptions.KEYSTORE_TYPE),
                         KEYSTORE_TYPE_DEFAULT);

            // The redirectPort for the non-SSL connector should match the port on
            // the SSL connector, per:
            // http://tomcat.apache.org/tomcat-5.0-doc/ssl-howto.html
            Element httpConnector =
                    (Element) getDocument()
                            .selectSingleNode(HTTP_CONNECTOR_XPATH);
            if (httpConnector != null) {
                httpConnector.addAttribute("redirectPort", options
                        .getValue(InstallOptions.TOMCAT_SSL_PORT));
            } else {
                throw new InstallationFailedException("Unable to set server.xml SSL Port. XPath for Connector element failed.");
            }
        } else if (httpsConnector != null) {
            httpsConnector.getParent().remove(httpsConnector);
        }
    }
860607
protected function setAccessDeniedError(AbstractResponseContainer $container)
    {
        $container->setStatus(PayoneApiConstants::RESPONSE_TYPE_ERROR);
        $container->setErrormessage(static::ERROR_ACCESS_DENIED_MESSAGE);
        $container->setCustomermessage(static::ERROR_ACCESS_DENIED_MESSAGE);
    }
387211
def set_pttl(self, key, ttl):
        
        return self._client.pexpire(self.get_key(key), ttl)
424806
def enable_disable_force_nat_t(self):
        
        if self.force_nat_t:
            self.data['force_nat_t'] = False
        else:
            self.data['force_nat_t'] = True
        self.update()
562982
public function set($key, $value, $ttl = 0)
    {
        $ttl = $this->fromDefaultTtl($ttl);

        if ($ttl >= 0) {
            $response = $this->curl->set($key, $this->storageDataStructure($value), $ttl);

            if (false !== $response) {
                $response = \json_decode($response, true);

                if (\array_key_exists('ok', $response) && true === $response['ok']) {
                    $this->setChain($key, $value, $ttl);
                }
            }
        }

        return $this;
    }
426462
public function setContainer(\Phrozn\Registry\Container $container = null)
    {
        $this->container = $container;
        return $this;
    }
652962
private IAtomContainer setAntiFlags(IAtomContainer container, IAtomContainer ac, int number, boolean b) {
        IBond bond = ac.getBond(number);
        if (!container.contains(bond)) {
            bond.setFlag(CDKConstants.REACTIVE_CENTER, b);
            bond.getBegin().setFlag(CDKConstants.REACTIVE_CENTER, b);
            bond.getEnd().setFlag(CDKConstants.REACTIVE_CENTER, b);
        } else
            return null;
        return ac;
    }
1100021
def enable(identifier = None, *args, **kwargs):
	'''  '''

	global cache
	if not identifier:
		for item in (config['default-caches'] + ['NoCache']):
			if caches.has_key(item):
				debug('Enabling default cache %s...' % (item,))
				cache = caches[item](*args, **kwargs)
				if not cache.status():
					warning('%s could not be loaded. Is the backend running (%s:%d)?' % (item, cache.server, cache.port))
					continue
				# This means that the cache backend was set up successfully
				break
			else:
				debug('Cache backend %s is not registered. Are all requirements satisfied?' % (item,))
	elif caches.has_key(identifier):
		debug('Enabling cache %s...' % (identifier,))
		previouscache = cache
		cache = caches[identifier](*args, **kwargs)
		if not cache.status():
			warning('%s could not be loaded. Is the backend running (%s:%d)?' % (identifier, cache.server, cache.port))
			cache = previouscache
	else:
		debug('Cache backend %s is not registered. Are all requirements satisfied?' % (identifier,))