class inner

v1.CloudRedisClient

Configures and manages Cloud Memorystore for Redis instances

Google Cloud Memorystore for Redis v1

The redis.googleapis.com service implements the Google Cloud Memorystore for Redis API and defines the following resource model for managing Redis instances:

The service works with a collection of cloud projects, named: /projects/*
Each project has a collection of available locations, named: /locations/*
Each location has a collection of Redis instances, named: /instances/*
As such, Redis instances are resources of the form: /projects/{project_id}/locations/{location_id}/instances/{instance_id}

Note that location_id must be referring to a GCP region; for example:

projects/redpepper-1290/locations/us-central1/instances/my-redis

Properties

apiEndpoint
port

scopes
servicePath

Methods

createInstance(request[, options][, callback])
deleteInstance(request[, options][, callback])
exportInstance(request[, options][, callback])
failoverInstance(request[, options][, callback])
getInstance(request[, options][, callback])
getProjectId(callback)

importInstance(request[, options][, callback])
instancePath(project, location, instance)
listInstances(request[, options][, callback])
listInstancesStream(request[, options])
locationPath(project, location)
matchInstanceFromInstanceName(instanceName)

matchLocationFromInstanceName(instanceName)
matchLocationFromLocationName(locationName)
matchProjectFromInstanceName(instanceName)
matchProjectFromLocationName(locationName)
updateInstance(request[, options][, callback])

new CloudRedisClient([options])

Construct an instance of CloudRedisClient.

Parameters

Name Type Optional Description

options

Yes

The configuration object. See the subsequent parameters for more details.

Values in options have the following properties:

Name	Optional	Description
credentials	Yes	Credentials object.
credentials.client_email	Yes
credentials.private_key	Yes
email	Yes	Account email address. Required when using a .pem or .p12 keyFilename.
keyFilename	Yes	Full path to the a .json, .pem, or .p12 key downloaded from the Google Developers Console. If you provide a path to a JSON file, the projectId option below is not necessary. NOTE: .pem and .p12 require you to specify options.email as well.
port	Yes	The port on which to connect to the remote host.
projectId	Yes	The project ID from the Google Developer's Console, e.g. 'grape-spaceship-123'. We will also check the environment variable GCLOUD_PROJECT for your project ID. If your app is running in an environment which supports Application Default Credentials, your project ID will be detected automatically.
promise	Yes	Custom promise module to use instead of native Promises.
servicePath	Yes	The domain name of the API remote host.

Properties

static

apiEndpoint

The DNS address for this API service - same as servicePath(), exists for compatibility reasons.

static

port

The port for this API service.

static

scopes

The scopes needed to make gRPC calls for every method defined in this service.

static

servicePath

The DNS address for this API service.

Methods

createInstance(request[, options][, callback]) → Promise

Creates a Redis instance based on the specified tier and memory size.

By default, the instance is accessible from the project's default network.

The creation is executed asynchronously and callers may check the returned operation to track its progress. Once the operation is completed the Redis instance will be fully functional. Completed longrunning.Operation will contain the new instance object in the response field.

The returned operation is automatically deleted after a few hours, so there is no need to call DeleteOperation.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');
const instanceId = 'test_instance';
const tier = 'BASIC';
const memorySizeGb = 1;
const instance = {
  tier: tier,
  memorySizeGb: memorySizeGb,
};
const request = {
  parent: formattedParent,
  instanceId: instanceId,
  instance: instance,
};

// Handle the operation using the promise pattern.
client.createInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');
const instanceId = 'test_instance';
const tier = 'BASIC';
const memorySizeGb = 1;
const instance = {
  tier: tier,
  memorySizeGb: memorySizeGb,
};
const request = {
  parent: formattedParent,
  instanceId: instanceId,
  instance: instance,
};

// Handle the operation using the event emitter pattern.
client.createInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');
const instanceId = 'test_instance';
const tier = 'BASIC';
const memorySizeGb = 1;
const instance = {
  tier: tier,
  memorySizeGb: memorySizeGb,
};
const request = {
  parent: formattedParent,
  instanceId: instanceId,
  instance: instance,
};

// Handle the operation using the await pattern.
const [operation] = await client.createInstance(request);

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name Type Optional Description

parent

string

Required. The resource name of the instance location using the form: projects/{project_id}/locations/{location_id} where location_id refers to a GCP region.

instanceId

string

Required. The logical name of the Redis instance in the customer project with the following restrictions:

Must contain only lowercase letters, numbers, and hyphens.
Must start with a letter.
Must be between 1-40 characters.
Must end with a number or a letter.
Must be unique within the customer project / location

instance

Object

Required. A Redis resource

This object should have the same structure as [Instance]Instance

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.

deleteInstance(request[, options][, callback]) → Promise

Deletes a specific Redis instance. Instance stops serving and data is deleted.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');

// Handle the operation using the promise pattern.
client.deleteInstance({name: formattedName})
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');

// Handle the operation using the event emitter pattern.
client.deleteInstance({name: formattedName})
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');

// Handle the operation using the await pattern.
const [operation] = await client.deleteInstance({name: formattedName});

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name	Type	Optional	Description
name	string		Required. Redis instance resource name using the form: `projects/{project_id}/locations/{location_id}/instances/{instance_id}` where `location_id` refers to a GCP region.

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.

exportInstance(request[, options][, callback]) → Promise

Export Redis instance data into a Redis RDB format file in Cloud Storage.

Redis will continue serving during this operation.

The returned operation is automatically deleted after a few hours, so there is no need to call DeleteOperation.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const outputConfig = {};
const request = {
  name: formattedName,
  outputConfig: outputConfig,
};

// Handle the operation using the promise pattern.
client.exportInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const outputConfig = {};
const request = {
  name: formattedName,
  outputConfig: outputConfig,
};

// Handle the operation using the event emitter pattern.
client.exportInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const outputConfig = {};
const request = {
  name: formattedName,
  outputConfig: outputConfig,
};

// Handle the operation using the await pattern.
const [operation] = await client.exportInstance(request);

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name Type Optional Description

name

string

Required. Redis instance resource name using the form: projects/{project_id}/locations/{location_id}/instances/{instance_id} where location_id refers to a GCP region.

outputConfig

Object

Required. Specify data to be exported.

This object should have the same structure as OutputConfig

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.

failoverInstance(request[, options][, callback]) → Promise

Initiates a failover of the master node to current replica node for a specific STANDARD tier Cloud Memorystore for Redis instance.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const dataProtectionMode = 'DATA_PROTECTION_MODE_UNSPECIFIED';
const request = {
  name: formattedName,
  dataProtectionMode: dataProtectionMode,
};

// Handle the operation using the promise pattern.
client.failoverInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const dataProtectionMode = 'DATA_PROTECTION_MODE_UNSPECIFIED';
const request = {
  name: formattedName,
  dataProtectionMode: dataProtectionMode,
};

// Handle the operation using the event emitter pattern.
client.failoverInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const dataProtectionMode = 'DATA_PROTECTION_MODE_UNSPECIFIED';
const request = {
  name: formattedName,
  dataProtectionMode: dataProtectionMode,
};

// Handle the operation using the await pattern.
const [operation] = await client.failoverInstance(request);

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name Type Optional Description

name

string

Required. Redis instance resource name using the form: projects/{project_id}/locations/{location_id}/instances/{instance_id} where location_id refers to a GCP region.

dataProtectionMode

number

Optional. Available data protection modes that the user can choose. If it's unspecified, data protection mode will be LIMITED_DATA_LOSS by default.

The number should be among the values of DataProtectionMode

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.

getInstance(request[, options][, callback]) → Promise

Gets the details of a specific Redis instance.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
client.getInstance({name: formattedName})
  .then(responses => {
    const response = responses[0];
    // doThingsWith(response)
  })
  .catch(err => {
    console.error(err);
  });

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name	Type	Optional	Description
name	string		Required. Redis instance resource name using the form: `projects/{project_id}/locations/{location_id}/instances/{instance_id}` where `location_id` refers to a GCP region.

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is an object representing Instance.

Returns

Promise

The promise which resolves to an array. The first element of the array is an object representing Instance. The promise has a method named "cancel" which cancels the ongoing API call.

getProjectId(callback)

Return the project ID used by this class.

Parameter

Name	Type	Optional	Description
callback	function(Error, string)		the callback to be called with the current project Id.

importInstance(request[, options][, callback]) → Promise

Import a Redis RDB snapshot file from Cloud Storage into a Redis instance.

Redis may stop serving during this operation. Instance state will be IMPORTING for entire operation. When complete, the instance will contain only data from the imported file.

The returned operation is automatically deleted after a few hours, so there is no need to call DeleteOperation.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const inputConfig = {};
const request = {
  name: formattedName,
  inputConfig: inputConfig,
};

// Handle the operation using the promise pattern.
client.importInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const inputConfig = {};
const request = {
  name: formattedName,
  inputConfig: inputConfig,
};

// Handle the operation using the event emitter pattern.
client.importInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const formattedName = client.instancePath('[PROJECT]', '[LOCATION]', '[INSTANCE]');
const inputConfig = {};
const request = {
  name: formattedName,
  inputConfig: inputConfig,
};

// Handle the operation using the await pattern.
const [operation] = await client.importInstance(request);

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name Type Optional Description

name

string

Required. Redis instance resource name using the form: projects/{project_id}/locations/{location_id}/instances/{instance_id} where location_id refers to a GCP region.

inputConfig

Object

Required. Specify data to be imported.

This object should have the same structure as InputConfig

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.

instancePath(project, location, instance) → String

Return a fully-qualified instance resource name string.

Parameters

Name	Type	Optional	Description
project	String
location	String
instance	String

Returns: String

listInstances(request[, options][, callback]) → Promise

Lists all Redis instances owned by a project in either the specified location (region) or all locations.

The location should have the following format:

projects/{project_id}/locations/{location_id}

If location_id is specified as - (wildcard), then all regions available to the project are queried, and the results are aggregated.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

// Iterate over all elements.
const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');

client.listInstances({parent: formattedParent})
  .then(responses => {
    const resources = responses[0];
    for (const resource of resources) {
      // doThingsWith(resource)
    }
  })
  .catch(err => {
    console.error(err);
  });

// Or obtain the paged response.
const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');


const options = {autoPaginate: false};
const callback = responses => {
  // The actual resources in a response.
  const resources = responses[0];
  // The next request if the response shows that there are more responses.
  const nextRequest = responses[1];
  // The actual response object, if necessary.
  // const rawResponse = responses[2];
  for (const resource of resources) {
    // doThingsWith(resource);
  }
  if (nextRequest) {
    // Fetch the next page.
    return client.listInstances(nextRequest, options).then(callback);
  }
}
client.listInstances({parent: formattedParent}, options)
  .then(callback)
  .catch(err => {
    console.error(err);
  });

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name	Type	Optional	Description
parent	string		Required. The resource name of the instance location using the form: `projects/{project_id}/locations/{location_id}` where `location_id` refers to a GCP region.
pageSize	number	Yes	The maximum number of resources contained in the underlying API response. If page streaming is performed per-resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page.

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Array, nullable Object, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is Array of Instance.

When autoPaginate: false is specified through options, it contains the result in a single response. If the response indicates the next page exists, the third parameter is set to be used for the next request object. The fourth parameter keeps the raw response object of an object representing ListInstancesResponse.

Returns

Promise

The promise which resolves to an array. The first element of the array is Array of Instance.

When autoPaginate: false is specified through options, the array has three elements. The first element is Array of Instance in a single response. The second element is the next request object if the response indicates the next page exists, or null. The third element is an object representing ListInstancesResponse.

The promise has a method named "cancel" which cancels the ongoing API call.

listInstancesStream(request[, options]) → Stream

Equivalent to listInstances, but returns a NodeJS Stream object.

This fetches the paged responses for listInstances continuously and invokes the callback registered for 'data' event for each element in the responses.

The returned object has 'end' method when no more elements are required.

autoPaginate option will be ignored.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const formattedParent = client.locationPath('[PROJECT]', '[LOCATION]');
client.listInstancesStream({parent: formattedParent})
  .on('data', element => {
    // doThingsWith(element)
  }).on('error', err => {
    console.log(err);
  });

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name	Type	Optional	Description
parent	string		Required. The resource name of the instance location using the form: `projects/{project_id}/locations/{location_id}` where `location_id` refers to a GCP region.
pageSize	number	Yes	The maximum number of resources contained in the underlying API response. If page streaming is performed per-resource, this parameter does not affect the return value. If page streaming is performed per-page, this determines the maximum number of resources in a page.

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

See also

https://nodejs.org/api/stream.html

Returns

Stream

An object stream which emits an object representing Instance on 'data' event.

locationPath(project, location) → String

Return a fully-qualified location resource name string.

Parameters

Name	Type	Optional	Description
project	String
location	String

Returns: String

matchInstanceFromInstanceName(instanceName) → String

Parse the instanceName from a instance resource.

Parameter

Name	Type	Optional	Description
instanceName	String		A fully-qualified path representing a instance resources.

Returns

String

A string representing the instance.

matchLocationFromInstanceName(instanceName) → String

Parse the instanceName from a instance resource.

Parameter

Name	Type	Optional	Description
instanceName	String		A fully-qualified path representing a instance resources.

Returns

String

A string representing the location.

matchLocationFromLocationName(locationName) → String

Parse the locationName from a location resource.

Parameter

Name	Type	Optional	Description
locationName	String		A fully-qualified path representing a location resources.

Returns

String

A string representing the location.

matchProjectFromInstanceName(instanceName) → String

Parse the instanceName from a instance resource.

Parameter

Name	Type	Optional	Description
instanceName	String		A fully-qualified path representing a instance resources.

Returns

String

A string representing the project.

matchProjectFromLocationName(locationName) → String

Parse the locationName from a location resource.

Parameter

Name	Type	Optional	Description
locationName	String		A fully-qualified path representing a location resources.

Returns

String

A string representing the project.

updateInstance(request[, options][, callback]) → Promise

Updates the metadata and configuration of a specific Redis instance.

Completed longrunning.Operation will contain the new instance object in the response field. The returned operation is automatically deleted after a few hours, so there is no need to call DeleteOperation.

Example

const redis = require('redis.v1');

const client = new redis.v1.CloudRedisClient({
  // optional auth parameters.
});

const pathsElement = 'display_name';
const pathsElement2 = 'memory_size_gb';
const paths = [pathsElement, pathsElement2];
const updateMask = {
  paths: paths,
};
const displayName = ' instance.memory_size_gb=4';
const instance = {
  displayName: displayName,
};
const request = {
  updateMask: updateMask,
  instance: instance,
};

// Handle the operation using the promise pattern.
client.updateInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Operation#promise starts polling for the completion of the LRO.
    return operation.promise();
  })
  .then(responses => {
    const result = responses[0];
    const metadata = responses[1];
    const finalApiResponse = responses[2];
  })
  .catch(err => {
    console.error(err);
  });

const pathsElement = 'display_name';
const pathsElement2 = 'memory_size_gb';
const paths = [pathsElement, pathsElement2];
const updateMask = {
  paths: paths,
};
const displayName = ' instance.memory_size_gb=4';
const instance = {
  displayName: displayName,
};
const request = {
  updateMask: updateMask,
  instance: instance,
};

// Handle the operation using the event emitter pattern.
client.updateInstance(request)
  .then(responses => {
    const [operation, initialApiResponse] = responses;

    // Adding a listener for the "complete" event starts polling for the
    // completion of the operation.
    operation.on('complete', (result, metadata, finalApiResponse) => {
      // doSomethingWith(result);
    });

    // Adding a listener for the "progress" event causes the callback to be
    // called on any change in metadata when the operation is polled.
    operation.on('progress', (metadata, apiResponse) => {
      // doSomethingWith(metadata)
    });

    // Adding a listener for the "error" event handles any errors found during polling.
    operation.on('error', err => {
      // throw(err);
    });
  })
  .catch(err => {
    console.error(err);
  });

const pathsElement = 'display_name';
const pathsElement2 = 'memory_size_gb';
const paths = [pathsElement, pathsElement2];
const updateMask = {
  paths: paths,
};
const displayName = ' instance.memory_size_gb=4';
const instance = {
  displayName: displayName,
};
const request = {
  updateMask: updateMask,
  instance: instance,
};

// Handle the operation using the await pattern.
const [operation] = await client.updateInstance(request);

const [response] = await operation.promise();

Parameters

Name Type Optional Description

request

Object

The request object that will be sent.

Values in request have the following properties:

Name Type Optional Description

updateMask

Object

Required. Mask of fields to update. At least one path must be supplied in this field. The elements of the repeated paths field may only include these fields from Instance:

displayName
labels
memorySizeGb
redisConfig

This object should have the same structure as FieldMask

instance

Object

Required. Update description. Only fields specified in update_mask are updated.

This object should have the same structure as Instance

options

Object

Yes

Optional parameters. You can override the default settings for this call, e.g, timeout, retries, paginations, etc. See gax.CallOptions for the details.

callback

function(nullable Error, nullable Object)

Yes

The function which will be called with the result of the API call.

The second parameter to the callback is a gax.Operation object.

Returns

Promise

The promise which resolves to an array. The first element of the array is a gax.Operation object. The promise has a method named "cancel" which cancels the ongoing API call.