<pre>
API backend configuration.
</pre>

<code>.google.api.Backend backend = 8;</code>
779372
public com.google.api.Backend getBackend() {
    return backend_ == null ? com.google.api.Backend.getDefaultInstance() : backend_;
  }
1168727
public OvhLoadBalancingBackendIp loadBalancing_serviceName_backend_backend_GET(String serviceName, String backend) throws IOException {
		String qPath = "/ip/loadBalancing/{serviceName}/backend/{backend}";
		StringBuilder sb = path(qPath, serviceName, backend);
		String resp = exec(qPath, "GET", sb.toString(), null);
		return convertTo(resp, OvhLoadBalancingBackendIp.class);
	}
1039636
def set_current_backend(cls, backend):
        ""
        for hook in cls._backend_switch_hooks:
            hook(backend)
        cls.current_backend = backend
1042856
function BackendStorage (gateway, opts){
    
    // prepare ourself to make debug possible
    this.uid="Dummy@nothing";
    this.gateway =gateway;
    this.debug=opts.debug;
    this.count=0;
    
    this.storesize= 20 +1;  // number of position slot/devices
    this.event = new EventEmitter();
}
352573
def _init_backends(self, config):
        
        self.backends_params = {}
        self.backends = {}
        self.backends_display_names = {}
        for entry in config['backends']:
            # split at the first dot
            backend, sep, param = entry.partition('.')
            value = config['backends'][entry]
            if backend not in self.backends_params:
                self.backends_params[backend] = {}
            self.backends_params[backend][param] = value
        for backend in self.backends_params:
            # get the backend display_name
            try:
                self.backends_display_names[backend] = \
                    self.backends_params[backend]['display_name']
            except Exception as e:
                self.backends_display_names[backend] = backend
                self.backends_params[backend]['display_name'] = backend
            params = self.backends_params[backend]
            # Loading the backend module
            try:
                module = params['module']
            except Exception as e:
                raise MissingParameter('backends', backend + '.module')
            try:
                bc = __import__(module, globals(), locals(), ['Backend'], 0)
            except Exception as e:
                self._handle_exception(e)
                raise BackendModuleLoadingFail(module)
            try:
                attrslist = self.attributes.get_backend_attributes(backend)
                key = self.attributes.get_backend_key(backend)
                self.backends[backend] = bc.Backend(
                    params,
                    cherrypy.log.error,
                    backend,
                    attrslist,
                    key,
                    )
            except MissingParameter as e:
                raise
            except Exception as e:
                self._handle_exception(e)
                raise BackendModuleInitFail(module)
1201780
function (backend) {

    backend.Debug (4, "MySQL creating connection [%s]", backend.uid);
    backend.base = mysql.createConnection(backend.opts);
    backend.count ++;
      
    // register event for asynchronous server errors
    backend.base.on('error', function(err) {
        backend.Debug (1, "MySQL server error=[%s]", err);
        // Sever was restarted or network connection was lost let restart connection
        if(err.code === 'PROTOCOL_CONNECTION_LOST') {
             backend.Debug (4, "MySQL connection lost [%s/%d] automatic connect retry in 10s]", backend.uid, backend.count);
             setTimeout(function () {CreateConnection (backend);}, MYSQL_RECONNECT_TIMER);  
             
        } else { 
            throw err;  // server variable configures this)
        };
    });
    
    // force an initial connectiion at object construction time
    backend.base.connect (function(err) {
        if (err) {
             backend.Debug (4, "MySQL connection fail [%s/%d] automatic connect retry in 10s]", backend.uid, backend.count);
             setTimeout(function () {CreateConnection (backend);}, MYSQL_RECONNECT_TIMER);  
            
        } else {
            backend.Debug (5,"MySQL Connect Done [%s]",  backend.uid);
        }
    });
}
194867
public com.google.appengine.v1.ApiEndpointHandlerOrBuilder getApiEndpointOrBuilder() {
    if (handlerTypeCase_ == 4) {
       return (com.google.appengine.v1.ApiEndpointHandler) handlerType_;
    }
    return com.google.appengine.v1.ApiEndpointHandler.getDefaultInstance();
  }
1179244
public function getBackendCache()
    {
        $backendCache = $this->typoScriptService->getExtensionConfigurationFromPath('settings.defaultBackendCache');

        if (false === class_exists($backendCache)) {
            throw ClassNotFoundException::backendCacheClassNameNotFound($backendCache);
        }

        if (false === in_array(BackendInterface::class, class_implements($backendCache))) {
            throw InvalidOptionValueException::wrongBackendCacheType($backendCache);
        }

        return $backendCache;
    }
851164
public static Map<String, String> backRequestByMap(Map<String, String> reqData) {
		return SDKUtil.convertResultStringToMap(backRequest(reqData));
	}
280017
def create_backend(self, 
		service_id,
		version_number, 
		name, 
		address,
		use_ssl=False,
		port=80,
		connect_timeout=1000,
		first_byte_timeout=15000,
		between_bytes_timeout=10000,
		error_threshold=0,
		max_conn=20,
		weight=100,
		auto_loadbalance=False,
		shield=None,
		request_condition=None,
		healthcheck=None,
		comment=None):
		""""""
		body = self._formdata({
			"name": name,
			"address": address,
			"use_ssl": use_ssl,
			"port": port,
			"connect_timeout": connect_timeout,
			"first_byte_timeout": first_byte_timeout,
			"between_bytes_timeout": between_bytes_timeout,
			"error_threshold": error_threshold,
			"max_conn": max_conn,
			"weight": weight,
			"auto_loadbalance": auto_loadbalance,
			"shield": shield,
			"request_condition": request_condition,
			"healthcheck": healthcheck,
			"comment": comment,
		}, FastlyBackend.FIELDS)
		content = self._fetch("/service/%s/version/%d/backend" % (service_id, version_number), method="POST", body=body)
		return FastlyBackend(self, content)
1286783
def parse_backend(backend):
    """"""
    r = urlparse.urlsplit(backend)
    scheme, host = r.scheme, r.netloc
    path, query = r.path, r.query
    if path and not query:
        query, path = path, ''
        if query:
            if query.find('?'):
                path = query
            else:
                query = query[1:]
    if query:
        params = dict(urlparse.parse_qsl(query))
    else:
        params = {}

    return scheme, host, params
1215535
public ApiResponse<GetConfigResponse> getConfigWithHttpInfo() throws ApiException {
        com.squareup.okhttp.Call call = getConfigValidateBeforeCall(null, null);
        Type localVarReturnType = new TypeToken<GetConfigResponse>(){}.getType();
        return apiClient.execute(call, localVarReturnType);
    }
788144
public java.util.List<BackendServerDescription> getBackendServerDescriptions() {
        if (backendServerDescriptions == null) {
            backendServerDescriptions = new com.amazonaws.internal.SdkInternalList<BackendServerDescription>();
        }
        return backendServerDescriptions;
    }
1195623
def _get_backend():
    
    enabled = [n for n, c in sorted(CACHES.items())
               if c.get('JOHNNY_CACHE', False)]
    if len(enabled) > 1:
        warn("Multiple caches configured for johnny-cache; using %s." %
             enabled[0])
    if enabled:
        return get_cache(enabled[0])
    if CACHE_BACKEND:
        backend = get_cache(CACHE_BACKEND)
        if backend not in CACHES:
            from django.core import signals
            # Some caches -- python-memcached in particular -- need to do a
            # cleanup at the end of a request cycle. If the cache provides a
            # close() method, wire it up here.
            if hasattr(backend, 'close'):
                signals.request_finished.connect(backend.close)
        return backend
    return cache
1092736
def _setup_backend(self):
        ''' 
        '''
        self.backends = []
        self.be_poller = zmq.Poller()
        for actual_backend_address in self.backend_address:
            # publisher or client socket
            actual_backend = (actual_backend_address,
                              self.context.socket(self.backend_socket_type))
            # Wait 0.5 s before termating socket
            actual_backend[1].setsockopt(zmq.LINGER, 500)
            # Buffer only 100 meassages, then throw data away
            actual_backend[1].set_hwm(10)
            actual_backend[1].bind(actual_backend_address)
            self.backends.append(actual_backend)
            if self.backend_socket_type != zmq.DEALER:
                self.be_poller.register(actual_backend[1], zmq.POLLIN)
        self.be_stop = threading.Event()
1041510
def import_backend(config):
    
    backend_name = config['backend']
    path = backend_name.split('.')
    backend_mod_name, backend_class_name = '.'.join(path[:-1]), path[-1]
    backend_mod = importlib.import_module(backend_mod_name)
    backend_class = getattr(backend_mod, backend_class_name)
    return backend_class(config['settings'])
1111238
def get_backend(self, service_id, version_number, name):
		""""""
		content = self._fetch("/service/%s/version/%d/backend/%s" % (service_id, version_number, name))
		return FastlyBackend(self, content)