Sets the ca_id of this DeviceData.
        The certificate issuer's ID.

        :param ca_id: The ca_id of this DeviceData.
        :type: str
355810
def ca_id(self, ca_id):
        
        if ca_id is not None and len(ca_id) > 500:
            raise ValueError("Invalid value for `ca_id`, length must be less than or equal to `500`")

        self._ca_id = ca_id
1019016
def __set_version_id(self):
        

        version_id = self.client.factory.create('VersionId')
        version_id.ServiceId = self._version_info['service_id']
        version_id.Major = self._version_info['major']
        version_id.Intermediate = self._version_info['intermediate']
        version_id.Minor = self._version_info['minor']
        self.logger.debug(version_id)
        self.VersionId = version_id
1310942
def _init_client_authentication(
            self,
            client_certchain_file: Optional[str],
            client_key_file: Optional[str],
            client_key_type: OpenSslFileTypeEnum,
            client_key_password: str,
            ignore_client_authentication_requests: bool
    ) -> None:
        
        if client_certchain_file is not None and client_key_file is not None:
            self._use_private_key(client_certchain_file, client_key_file, client_key_type, client_key_password)

        if ignore_client_authentication_requests:
            if client_certchain_file:
                raise ValueError('Cannot enable both client_certchain_file and ignore_client_authentication_requests')

            self._ssl_ctx.set_client_cert_cb_NULL()
1256035
def cred_def_id(self, issuer_did: str, schema_seq_no: int) -> str:
        

        return '{}:3:CL:{}{}'.format(  # 3 marks indy cred def id, CL is sig type
            issuer_did,
            schema_seq_no,
            self.cd_id_tag(True))
1345
def device_key(self, device_key):
        
        if device_key is not None and len(device_key) > 512:
            raise ValueError("Invalid value for `device_key`, length must be less than or equal to `512`")

        self._device_key = device_key
203205
def configure(cert)
      cert.version = 2
      cert.serial = serial
      cert.subject = OpenSSL::X509::Name.parse(name)
      cert.issuer = cert.subject
      cert.public_key = key.public_key
      cert.not_before = days_ago(2)
      cert.not_after = days_from_now(2)
    end
1366120
def verify_cb(conn, cert, errnum, depth, ok):
    
    if not ok:
        raise SecurityError("Could not verify CA certificate {0}"
                            .format(cert.get_subject()))
    return ok
735672
def request_control(self, device_id, access_mode=True):
        
        if access_mode:
            if not request_control(self.corsair_sdk, device_id):
                self._raise_corsair_error()
            return True
        else:
            self.reload()
1193677
def set_zone_variable(self, zone_id, variable, value):
        
        return self._send_cmd("SET %s.%s=\"%s\"" % (
            zone_id.device_str(), variable, value))
672766
def set_record(self, name, record_id, record):
        
        if name not in self._cache:
            self._cache[name] = {}
        self._cache[name][record_id] = record
953446
def chain_id(chain_id: int, chain_class: Type[BaseChain]) -> Type[BaseChain]:
    
    return chain_class.configure(chain_id=chain_id)
273117
public static function setClientId($client_id){
      if (!isset(self::$_config)){
        self::initialize();
      }
      self::$_config->configure(['CLIENT_ID' => $client_id]); 
    }
1123369
def set_credentials(self, client_id=None, client_secret=None):
        
        self._client_id = client_id
        self._client_secret = client_secret

        # make sure to reset session due to credential change
        self._session = None
979625
private function setCasCaCertPath($ca_file)
    {
        if ($ca_file === 'none') {
            phpCAS::setNoCasServerValidation();
        } else {
            if (file_exists($ca_file) && is_readable($ca_file)) {
                phpCAS::setCasServerCACert($ca_file);
            } else {
                throw new Exception("Unable to read CAS CA-Cert file: " . $ca_file, 500);
            }
        }
    }
983685
def set_system_id(self, system_id):
        

        yield from self._hypervisor.send('{platform} set_system_id "{name}" {system_id}'.format(platform=self._platform,
                                                                                                name=self._name,
                                                                                                system_id=system_id))

        log.info('Router "{name}" [{id}]: system ID updated from {old_id} to {new_id}'.format(name=self._name,
                                                                                              id=self._id,
                                                                                              old_id=self._system_id,
                                                                                              new_id=system_id))
        self._system_id = system_id
468137
def install_ca_cert(ca_cert, name=None):
    
    if not ca_cert:
        return
    if not isinstance(ca_cert, bytes):
        ca_cert = ca_cert.encode('utf8')
    if not name:
        name = 'juju-{}'.format(charm_name())
    cert_file = '/usr/local/share/ca-certificates/{}.crt'.format(name)
    new_hash = hashlib.md5(ca_cert).hexdigest()
    if file_hash(cert_file) == new_hash:
        return
    log("Installing new CA cert at: {}".format(cert_file), level=INFO)
    write_file(cert_file, ca_cert)
    subprocess.check_call(['update-ca-certificates', '--fresh'])
802298
def _coerce_client_id(client_id):
    
    if isinstance(client_id, type(u'')):
        client_id = client_id.encode('utf-8')
    if not isinstance(client_id, bytes):
        raise TypeError('{!r} is not a valid consumer group (must be'
                        ' str or bytes)'.format(client_id))
    return client_id