Get an instance of ambiente services facade.
356911
def create_ambiente(self):
        """"""
        return Ambiente(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
517483
def get_environment(self):
        '''
        
        '''
        env = {}
        if self.http:
            env['http_proxy'] = env['HTTP_PROXY'] = self.http
        if self.https:
            env['https_proxy'] = env['HTTPS_PROXY'] = self.https
        if self.ftp:
            env['ftp_proxy'] = env['FTP_PROXY'] = self.ftp
        if self.no_proxy:
            env['no_proxy'] = env['NO_PROXY'] = self.no_proxy
        return env
817763
def get_instance(self, service_name):
        
        for resource in self.space._get_instances():
            if resource['entity']['name'] == service_name:
                return resource['entity']
758531
def create_api_environment_vip(self):
        """"""
        return ApiEnvironmentVip(
            self.networkapi_url,
            self.user,
            self.password,
            self.user_ldap)
820704
def get(cls):
        
        apikey = cls.__api_key or cls.__api_key_env_var

        if apikey:
            return apikey
        else:
            raise APIKeyMissingError("API key not set")
919435
def get_environment(self, environment_ids):
        

        uri = 'api/v3/environment/%s/' % environment_ids

        return super(ApiEnvironment, self).get(uri)
722409
public ModelServiceInstance getModelServiceInstanceByAddress(String serviceName, String instanceAddress) {
        ModelService service = getModelService(serviceName);
        if (service != null && service.getServiceInstances() != null) {
            for (ModelServiceInstance instance : service.getServiceInstances()) {
                if (instance.getAddress().equals(instanceAddress)) {
                    return instance;
                }
            }
        }
        return null;
    }
733420
def _get_instance(self):
        """"""
        resource = self._connect()

        try:
            instance = resource.Instance(self.running_instance_id)
        except Exception:
            raise EC2CloudException(
                'Instance with ID: {instance_id} not found.'.format(
                    instance_id=self.running_instance_id
                )
            )
        return instance
928694
public Object startupService(BundleContext bundleContext)
    {
        Map<String,Object> props = this.getServiceProperties();
	    return Environment.getEnvironment(props);	// There is no need to check if it is already up (only 1 can run)
    }
14743
def app(environ, start_response):
    """"""
    r = HttpRequestHandler(environ, start_response, Router).dispatch()
    return r
688566
def get_spontaneous_environment(*args):
    
    try:
        env = _spontaneous_environments.get(args)
    except TypeError:
        return Environment(*args)
    if env is not None:
        return env
    _spontaneous_environments[args] = env = Environment(*args)
    env.shared = True
    return env
252311
def get(self, request, bot_id, id, format=None):
                
        return super(EnvironmentVarDetail, self).get(request, bot_id, id, format)
850014
@Override
  public Service get() {
    String serviceName = this.environment.getVariable(SERVICE_NAME_KEY);
    if (Strings.isNullOrEmpty(serviceName)) {
      String errorMessage =
          String.format("Environment variable '%s' is not set", SERVICE_NAME_KEY);
      throw new IllegalArgumentException(errorMessage);
    }
    String serviceVersion = this.environment.getVariable(SERVICE_VERSION_KEY);

    return fetch(serviceName, serviceVersion);
  }
1060695
def get_instance(self, payload):
        
        return UserInstance(self._version, payload, service_sid=self._solution['service_sid'], )
231250
def _start_services(self, console_env):
        """"""
        self._ad.services.register('sl4a', sl4a_service.Sl4aService)
        console_env['s'] = self._ad.services.sl4a
        console_env['sl4a'] = self._ad.sl4a
        console_env['ed'] = self._ad.ed
229243
def get_instance(self, payload):
        
        return BindingInstance(self._version, payload, service_sid=self._solution['service_sid'], )
1371546
def get_environ(self, sock):
        """"""
        cipher = sock.cipher()
        ssl_environ = {
            'wsgi.url_scheme': 'https',
            'HTTPS': 'on',
            'SSL_PROTOCOL': cipher[1],
            'SSL_CIPHER': cipher[0],
            # SSL_VERSION_INTERFACE     string  The mod_ssl program version
            # SSL_VERSION_LIBRARY   string  The OpenSSL program version
        }

        if self.context and self.context.verify_mode != ssl.CERT_NONE:
            client_cert = sock.getpeercert()
            if client_cert:
                for cert_key, env_var in self.CERT_KEY_TO_ENV.items():
                    ssl_environ.update(
                        self.env_dn_dict(env_var, client_cert.get(cert_key)),
                    )

        return ssl_environ