Class v1beta2.CloudMemcacheClient (4.1.0)

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Resource name of the Memcached instance for which parameter group updates 
 *  should be applied. 
 */ 
  
 // const name = 'abc123' 
  
 /** 
 *  Nodes to which the instance-level parameter group is applied. 
 */ 
  
 // const nodeIds = ['abc','def'] 
  
 /** 
 *  Whether to apply instance-level parameter group to all nodes. If set to 
 *  true, users are restricted from specifying individual nodes, and 
 *  `ApplyParameters` updates all nodes within the instance. 
 */ 
  
 // const applyAll = true 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callApplyParameters 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 applyParameters 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callApplyParameters 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Resource name of the Memcached instance for which software update should be 
 *  applied. 
 */ 
  
 // const instance = 'abc123' 
  
 /** 
 *  Nodes to which we should apply the update to. Note all the selected nodes 
 *  are updated in parallel. 
 */ 
  
 // const nodeIds = ['abc','def'] 
  
 /** 
 *  Whether to apply the update to all nodes. If set to 
 *  true, will explicitly restrict users from specifying any nodes, and apply 
 *  software update to all nodes (where applicable) within the instance. 
 */ 
  
 // const applyAll = true 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callApplySoftwareUpdate 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 instance 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 applySoftwareUpdate 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callApplySoftwareUpdate 
 (); 
 

  const 
  
 client 
  
 = 
  
 longrunning 
 . 
 operationsClient 
 (); 
 await 
  
 client 
 . 
 cancelOperation 
 ({ 
 name 
 : 
  
 '' 
 }); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Resource name of the Memcached instance for which parameter group updates 
 *  should be applied. 
 */ 
  
 // const name = 'abc123' 
  
 /** 
 *  Nodes to which the instance-level parameter group is applied. 
 */ 
  
 // const nodeIds = ['abc','def'] 
  
 /** 
 *  Whether to apply instance-level parameter group to all nodes. If set to 
 *  true, users are restricted from specifying individual nodes, and 
 *  `ApplyParameters` updates all nodes within the instance. 
 */ 
  
 // const applyAll = true 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callApplyParameters 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 applyParameters 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callApplyParameters 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Resource name of the Memcached instance for which software update should be 
 *  applied. 
 */ 
  
 // const instance = 'abc123' 
  
 /** 
 *  Nodes to which we should apply the update to. Note all the selected nodes 
 *  are updated in parallel. 
 */ 
  
 // const nodeIds = ['abc','def'] 
  
 /** 
 *  Whether to apply the update to all nodes. If set to 
 *  true, will explicitly restrict users from specifying any nodes, and apply 
 *  software update to all nodes (where applicable) within the instance. 
 */ 
  
 // const applyAll = true 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callApplySoftwareUpdate 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 instance 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 applySoftwareUpdate 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callApplySoftwareUpdate 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  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 
 */ 
  
 // const parent = 'abc123' 
  
 /** 
 *  Required. The logical name of the Memcached instance in the user 
 *  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 user project / location. 
 *  If any of the above are not met, the API raises an invalid argument error. 
 */ 
  
 // const instanceId = 'abc123' 
  
 /** 
 *  Required. A Memcached Instance  resource 
 */ 
  
 // const resource = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callCreateInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 parent 
 , 
  
 instanceId 
 , 
  
 resource 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 createInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callCreateInstance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Memcached instance resource name in the format: 
 *      `projects/{project_id}/locations/{location_id}/instances/{instance_id}` 
 *  where `location_id` refers to a GCP region 
 */ 
  
 // const name = 'abc123' 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callDeleteInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 deleteInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callDeleteInstance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Memcache instance resource name using the form: 
 *      `projects/{project_id}/locations/{location_id}/instances/{instance_id}` 
 *  where `location_id` refers to a GCP region. 
 */ 
  
 // const instance = 'abc123' 
  
 /** 
 *  Required. If reschedule type is SPECIFIC_TIME, must set up schedule_time as well. 
 */ 
  
 // const rescheduleType = {} 
  
 /** 
 *  Timestamp when the maintenance shall be rescheduled to if 
 *  reschedule_type=SPECIFIC_TIME, in RFC 3339 format, for 
 *  example `2012-11-15T16:19:00.094Z`. 
 */ 
  
 // const scheduleTime = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callRescheduleMaintenance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 instance 
 , 
  
 rescheduleType 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 rescheduleMaintenance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callRescheduleMaintenance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Mask of fields to update. 
 *   *  `displayName` 
 */ 
  
 // const updateMask = {} 
  
 /** 
 *  Required. A Memcached Instance  resource. 
 *  Only fields specified in update_mask are updated. 
 */ 
  
 // const resource = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callUpdateInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 updateMask 
 , 
  
 resource 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 updateInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callUpdateInstance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Resource name of the Memcached instance for which the parameters should be 
 *  updated. 
 */ 
  
 // const name = 'abc123' 
  
 /** 
 *  Required. Mask of fields to update. 
 */ 
  
 // const updateMask = {} 
  
 /** 
 *  The parameters to apply to the instance. 
 */ 
  
 // const parameters = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callUpdateParameters 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 updateMask 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 updateParameters 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callUpdateParameters 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  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 
 */ 
  
 // const parent = 'abc123' 
  
 /** 
 *  Required. The logical name of the Memcached instance in the user 
 *  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 user project / location. 
 *  If any of the above are not met, the API raises an invalid argument error. 
 */ 
  
 // const instanceId = 'abc123' 
  
 /** 
 *  Required. A Memcached Instance  resource 
 */ 
  
 // const resource = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callCreateInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 parent 
 , 
  
 instanceId 
 , 
  
 resource 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 createInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callCreateInstance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Memcached instance resource name in the format: 
 *      `projects/{project_id}/locations/{location_id}/instances/{instance_id}` 
 *  where `location_id` refers to a GCP region 
 */ 
  
 // const name = 'abc123' 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callDeleteInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 deleteInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callDeleteInstance 
 (); 
 

  const 
  
 client 
  
 = 
  
 longrunning 
 . 
 operationsClient 
 (); 
 await 
  
 client 
 . 
 deleteOperation 
 ({ 
 name 
 : 
  
 '' 
 }); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Memcached instance resource name in the format: 
 *      `projects/{project_id}/locations/{location_id}/instances/{instance_id}` 
 *  where `location_id` refers to a GCP region 
 */ 
  
 // const name = 'abc123' 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callGetInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 name 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 response 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 getInstance 
 ( 
 request 
 ); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callGetInstance 
 (); 
 

  const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 client 
 . 
 getLocation 
 ( 
 request 
 ); 
 

  const 
  
 client 
  
 = 
  
 longrunning 
 . 
 operationsClient 
 (); 
 const 
  
 name 
  
 = 
  
 '' 
 ; 
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 client 
 . 
 getOperation 
 ({ 
 name 
 }); 
 // doThingsWith(response) 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  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 
 */ 
  
 // const parent = 'abc123' 
  
 /** 
 *  The maximum number of items to return. 
 *  If not specified, a default value of 1000 will be used by the service. 
 *  Regardless of the `page_size` value, the response may include a partial 
 *  list and a caller should only rely on response's 
 *  `next_page_token` google.cloud.memcache.v1beta2.ListInstancesResponse.next_page_token 
 *  to determine if there are more instances left to be queried. 
 */ 
  
 // const pageSize = 1234 
  
 /** 
 *  The `next_page_token` value returned from a previous List request, if any. 
 */ 
  
 // const pageToken = 'abc123' 
  
 /** 
 *  List filter. For example, exclude all Memcached instances with name as 
 *  my-instance by specifying `"name != my-instance"`. 
 */ 
  
 // const filter = 'abc123' 
  
 /** 
 *  Sort results. Supported values are "name", "name desc" or "" (unsorted). 
 */ 
  
 // const orderBy = 'abc123' 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callListInstances 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 parent 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 iterable 
  
 = 
  
 memcacheClient 
 . 
 listInstancesAsync 
 ( 
 request 
 ); 
  
 for 
  
 await 
  
 ( 
 const 
  
 response 
  
 of 
  
 iterable 
 ) 
  
 { 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 } 
  
 callListInstances 
 (); 
 

  const 
  
 iterable 
  
 = 
  
 client 
 . 
 listLocationsAsync 
 ( 
 request 
 ); 
 for 
  
 await 
  
 ( 
 const 
  
 response 
  
 of 
  
 iterable 
 ) 
  
 { 
  
 // process response 
 } 
 

  const 
  
 client 
  
 = 
  
 longrunning 
 . 
 operationsClient 
 (); 
 for 
  
 await 
  
 ( 
 const 
  
 response 
  
 of 
  
 client 
 . 
 listOperationsAsync 
 ( 
 request 
 )); 
 // doThingsWith(response) 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Memcache instance resource name using the form: 
 *      `projects/{project_id}/locations/{location_id}/instances/{instance_id}` 
 *  where `location_id` refers to a GCP region. 
 */ 
  
 // const instance = 'abc123' 
  
 /** 
 *  Required. If reschedule type is SPECIFIC_TIME, must set up schedule_time as well. 
 */ 
  
 // const rescheduleType = {} 
  
 /** 
 *  Timestamp when the maintenance shall be rescheduled to if 
 *  reschedule_type=SPECIFIC_TIME, in RFC 3339 format, for 
 *  example `2012-11-15T16:19:00.094Z`. 
 */ 
  
 // const scheduleTime = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callRescheduleMaintenance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 instance 
 , 
  
 rescheduleType 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 rescheduleMaintenance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callRescheduleMaintenance 
 (); 
 

   
 /** 
 * This snippet has been automatically generated and should be regarded as a code template only. 
 * It will require modifications to work. 
 * It may require correct/in-range values for request initialization. 
 * TODO(developer): Uncomment these variables before running the sample. 
 */ 
  
 /** 
 *  Required. Mask of fields to update. 
 *   *  `displayName` 
 */ 
  
 // const updateMask = {} 
  
 /** 
 *  Required. A Memcached Instance  resource. 
 *  Only fields specified in update_mask are updated. 
 */ 
  
 // const resource = {} 
  
 // Imports the Memcache library 
  
 const 
  
 { 
 CloudMemcacheClient 
 } 
  
 = 
  
 require 
 ( 
 ' @google-cloud/memcache 
' 
 ). 
 v1beta2 
 ; 
  
 // Instantiates a client 
  
 const 
  
 memcacheClient 
  
 = 
  
 new 
  
  CloudMemcacheClient 
 
 (); 
  
 async 
  
 function 
  
 callUpdateInstance 
 () 
  
 { 
  
 // Construct request 
  
 const 
  
 request 
  
 = 
  
 { 
  
 updateMask 
 , 
  
 resource 
 , 
  
 }; 
  
 // Run request 
  
 const 
  
 [ 
 operation 
 ] 
  
 = 
  
 await 
  
 memcacheClient 
 . 
 updateInstance 
 ( 
 request 
 ); 
  
 const 
  
 [ 
 response 
 ] 
  
 = 
  
 await 
  
 operation 
 . 
 promise 
 (); 
  
 console 
 . 
 log 
 ( 
 response 
 ); 
  
 } 
  
 callUpdateInstance 
 ();