Create a new instance for the specified host and encryption key.

@see #create(String)
503207
public static Thumbor create(String host, String key) {
    if (key == null || key.length() == 0) {
      throw new IllegalArgumentException("Key must not be blank.");
    }
    return new Thumbor(host, key);
  }
130420
private static Object createKeyPair() throws NoSuchAlgorithmException, NoSuchProviderException, InvalidKeyException {
        Class keyGenClass = lookupKeyGenClass();
        Object keypair = ClassUtil.newInstance(keyGenClass, "RSA", "SHA1WithRSA");
        ClassUtil.applyMethod(keypair, "generate", 2048);
        return keypair;
    }
205327
public static base_response create(nitro_service client, ssldhparam resource) throws Exception {
		ssldhparam createresource = new ssldhparam();
		createresource.dhfile = resource.dhfile;
		createresource.bits = resource.bits;
		createresource.gen = resource.gen;
		return createresource.perform_operation(client,"create");
	}
557538
public static RedisClusterManager newInstance(String host, int port, String password) {
        return newInstance(buildRedisConfig(host, port, password));
    }
806749
public static KeyPair newKeyPair(final PublicKey publicKey, final PrivateKey privateKey)
	{
		final KeyPair keyPair = new KeyPair(publicKey, privateKey);
		return keyPair;
	}
1250322
public static RedisURI create(String host, int port) {
        return Builder.redis(host, port).build();
    }
1062433
public static function create($host = self::DATADOG_DEFAULT_SERVER, $port = self::DATADOG_DEFAULT_PORT)
    {
        return new static(
            new Socket(), 
            $host ? $host : self::DATADOG_DEFAULT_SERVER, 
            $port ? $port : self::DATADOG_DEFAULT_PORT
        );
    }
741846
@NotNull
    public static Key<String> stringKey(@NotNull String name) {
        return create(name, String.class);
    }
973059
def create(entity)
      url = "#{DEFAULT_HOST}/#{entity.path}"
      uri = URI(url)
      response = http_response(:post, uri, body: entity.to_hash)
      entity.attributes = JSON.parse(response.body)
      entity
    end
855045
def create(gandi, vhost, paas, ssl, private_key, alter_zone, poll_cert,
           background):
    
    if not gandi.hostedcert.activate_ssl(vhost, ssl, private_key, poll_cert):
        return

    paas_info = gandi.paas.info(paas)
    result = gandi.vhost.create(paas_info, vhost, alter_zone, background)

    if background:
        gandi.pretty_echo(result)

    return result
556257
public static base_response create(nitro_service client, ssldsakey resource) throws Exception {
		ssldsakey createresource = new ssldsakey();
		createresource.keyfile = resource.keyfile;
		createresource.bits = resource.bits;
		createresource.keyform = resource.keyform;
		createresource.des = resource.des;
		createresource.des3 = resource.des3;
		createresource.password = resource.password;
		return createresource.perform_operation(client,"create");
	}
432768
def create(vm_=None, call=None):
    '''
    
    '''
    if call:
        raise SaltCloudSystemExit(
            'You cannot create an instance with -a or -f.'
        )

    node_info = request_instance(vm_)
    if isinstance(node_info, bool):
        raise SaltCloudSystemExit(
            'There was an error creating the GCE instance.'
        )
    node_dict = node_info[0]
    node_data = node_info[1]

    ssh_user, ssh_key = __get_ssh_credentials(vm_)
    vm_['ssh_host'] = __get_host(node_data, vm_)
    vm_['key_filename'] = ssh_key

    ret = __utils__['cloud.bootstrap'](vm_, __opts__)

    ret.update(node_dict)

    log.info('Created Cloud VM \'%s\'', vm_['name'])
    log.trace(
        '\'%s\' VM creation details:\n%s',
        vm_['name'], pprint.pformat(node_dict)
    )

    __utils__['cloud.fire_event'](
        'event',
        'created instance',
        'salt/cloud/{0}/created'.format(vm_['name']),
        args=__utils__['cloud.filter_event']('created', vm_, ['name', 'profile', 'provider', 'driver']),
        sock_dir=__opts__['sock_dir'],
        transport=__opts__['transport']
    )

    return ret
711302
public static base_response create(nitro_service client, sslfipskey resource) throws Exception {
		sslfipskey createresource = new sslfipskey();
		createresource.fipskeyname = resource.fipskeyname;
		createresource.modulus = resource.modulus;
		createresource.exponent = resource.exponent;
		return createresource.perform_operation(client,"create");
	}
54502
@Override
    protected final T create(Object... args) {
        final K key = this.getKey(args);
        final T value = this.createInternal(key, args);
        this.objectCache.put(key, value);
        return value;
    }
509549
@Override
  public final M create(final Map<String, Object> pAddParam) throws Exception {
    M object = this.objectClass.newInstance();
    object.setIsNew(false);
    object.setIdDatabaseBirth(this.databaseId);
    return object;
  }
1134563
public static base_response create(nitro_service client, sslwrapkey resource) throws Exception {
		sslwrapkey createresource = new sslwrapkey();
		createresource.wrapkeyname = resource.wrapkeyname;
		createresource.password = resource.password;
		createresource.salt = resource.salt;
		return createresource.perform_operation(client,"create");
	}
1133728
def create(key_body)
      client.ensure_master_key!

      path = ""
      response = access_keys_post(client.master_key, path, key_body)
      client.process_response(response.code.to_i, response.body)
    end