azure_mgmt_redis 0.6.0 → 0.7.0

Sign up to get free protection for your applications and to get access to all the features.
@@ -6,7 +6,7 @@
6
6
  module Azure::ARM::Redis
7
7
  module Models
8
8
  #
9
- # Model object.
9
+ # Patch schedule entry for Premium Redis Cache.
10
10
  #
11
11
  class ScheduleEntry
12
12
 
@@ -41,7 +41,8 @@ module Azure::ARM::Redis
41
41
  required: true,
42
42
  serialized_name: 'dayOfWeek',
43
43
  type: {
44
- name: 'String'
44
+ name: 'Enum',
45
+ module: 'DayOfWeek'
45
46
  }
46
47
  },
47
48
  start_hour_utc: {
@@ -27,12 +27,12 @@ module Azure::ARM::Redis
27
27
  #
28
28
  # @param resource_group_name [String] The name of the resource group.
29
29
  # @param name [String] The name of the redis cache.
30
- # @param parameters [RedisPatchSchedulesRequest] Parameters to set patch
31
- # schedules for redis cache.
30
+ # @param parameters [RedisPatchSchedule] Parameters to set patch schedules for
31
+ # redis cache.
32
32
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
33
33
  # will be added to the HTTP request.
34
34
  #
35
- # @return [RedisPatchSchedulesResponse] operation results.
35
+ # @return [RedisPatchSchedule] operation results.
36
36
  #
37
37
  def create_or_update(resource_group_name, name, parameters, custom_headers = nil)
38
38
  response = create_or_update_async(resource_group_name, name, parameters, custom_headers).value!
@@ -44,8 +44,8 @@ module Azure::ARM::Redis
44
44
  #
45
45
  # @param resource_group_name [String] The name of the resource group.
46
46
  # @param name [String] The name of the redis cache.
47
- # @param parameters [RedisPatchSchedulesRequest] Parameters to set patch
48
- # schedules for redis cache.
47
+ # @param parameters [RedisPatchSchedule] Parameters to set patch schedules for
48
+ # redis cache.
49
49
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
50
50
  # will be added to the HTTP request.
51
51
  #
@@ -60,8 +60,8 @@ module Azure::ARM::Redis
60
60
  #
61
61
  # @param resource_group_name [String] The name of the resource group.
62
62
  # @param name [String] The name of the redis cache.
63
- # @param parameters [RedisPatchSchedulesRequest] Parameters to set patch
64
- # schedules for redis cache.
63
+ # @param parameters [RedisPatchSchedule] Parameters to set patch schedules for
64
+ # redis cache.
65
65
  # @param [Hash{String => String}] A hash of custom headers that will be added
66
66
  # to the HTTP request.
67
67
  #
@@ -84,42 +84,39 @@ module Azure::ARM::Redis
84
84
  request_headers['Content-Type'] = 'application/json; charset=utf-8'
85
85
 
86
86
  # Serialize Request
87
- request_mapper = RedisPatchSchedulesRequest.mapper()
87
+ request_mapper = RedisPatchSchedule.mapper()
88
88
  request_content = @client.serialize(request_mapper, parameters, 'parameters')
89
89
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
90
90
 
91
91
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/patchSchedules/default'
92
+
93
+ request_url = @base_url || @client.base_url
94
+
92
95
  options = {
93
96
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
94
97
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
95
98
  query_params: {'api-version' => @client.api_version},
96
99
  body: request_content,
97
- headers: request_headers.merge(custom_headers || {})
100
+ headers: request_headers.merge(custom_headers || {}),
101
+ base_url: request_url
98
102
  }
103
+ promise = @client.make_request_async(:put, path_template, options)
99
104
 
100
- request_url = @base_url || @client.base_url
101
-
102
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :put, options)
103
- promise = request.run_promise do |req|
104
- @client.credentials.sign_request(req) unless @client.credentials.nil?
105
- end
106
-
107
- promise = promise.then do |http_response|
105
+ promise = promise.then do |result|
106
+ http_response = result.response
108
107
  status_code = http_response.status
109
108
  response_content = http_response.body
110
109
  unless status_code == 200
111
110
  error_model = JSON.load(response_content)
112
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
111
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
113
112
  end
114
113
 
115
- # Create Result
116
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
117
114
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
118
115
  # Deserialize Response
119
116
  if status_code == 200
120
117
  begin
121
118
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
122
- result_mapper = RedisPatchSchedulesResponse.mapper()
119
+ result_mapper = RedisPatchSchedule.mapper()
123
120
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
124
121
  rescue Exception => e
125
122
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
@@ -183,30 +180,27 @@ module Azure::ARM::Redis
183
180
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
184
181
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
185
182
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/patchSchedules/default'
183
+
184
+ request_url = @base_url || @client.base_url
185
+
186
186
  options = {
187
187
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
188
188
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
189
189
  query_params: {'api-version' => @client.api_version},
190
- headers: request_headers.merge(custom_headers || {})
190
+ headers: request_headers.merge(custom_headers || {}),
191
+ base_url: request_url
191
192
  }
193
+ promise = @client.make_request_async(:delete, path_template, options)
192
194
 
193
- request_url = @base_url || @client.base_url
194
-
195
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :delete, options)
196
- promise = request.run_promise do |req|
197
- @client.credentials.sign_request(req) unless @client.credentials.nil?
198
- end
199
-
200
- promise = promise.then do |http_response|
195
+ promise = promise.then do |result|
196
+ http_response = result.response
201
197
  status_code = http_response.status
202
198
  response_content = http_response.body
203
199
  unless status_code == 200
204
200
  error_model = JSON.load(response_content)
205
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
201
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
206
202
  end
207
203
 
208
- # Create Result
209
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
210
204
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
211
205
 
212
206
  result
@@ -223,7 +217,7 @@ module Azure::ARM::Redis
223
217
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
224
218
  # will be added to the HTTP request.
225
219
  #
226
- # @return [RedisPatchSchedulesResponse] operation results.
220
+ # @return [RedisPatchSchedule] operation results.
227
221
  #
228
222
  def get(resource_group_name, name, custom_headers = nil)
229
223
  response = get_async(resource_group_name, name, custom_headers).value!
@@ -267,36 +261,33 @@ module Azure::ARM::Redis
267
261
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
268
262
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
269
263
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/patchSchedules/default'
264
+
265
+ request_url = @base_url || @client.base_url
266
+
270
267
  options = {
271
268
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
272
269
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
273
270
  query_params: {'api-version' => @client.api_version},
274
- headers: request_headers.merge(custom_headers || {})
271
+ headers: request_headers.merge(custom_headers || {}),
272
+ base_url: request_url
275
273
  }
274
+ promise = @client.make_request_async(:get, path_template, options)
276
275
 
277
- request_url = @base_url || @client.base_url
278
-
279
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
280
- promise = request.run_promise do |req|
281
- @client.credentials.sign_request(req) unless @client.credentials.nil?
282
- end
283
-
284
- promise = promise.then do |http_response|
276
+ promise = promise.then do |result|
277
+ http_response = result.response
285
278
  status_code = http_response.status
286
279
  response_content = http_response.body
287
- unless status_code == 200
280
+ unless status_code == 200 || status_code == 404
288
281
  error_model = JSON.load(response_content)
289
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
282
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
290
283
  end
291
284
 
292
- # Create Result
293
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
294
285
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
295
286
  # Deserialize Response
296
287
  if status_code == 200
297
288
  begin
298
289
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
299
- result_mapper = RedisPatchSchedulesResponse.mapper()
290
+ result_mapper = RedisPatchSchedule.mapper()
300
291
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
301
292
  rescue Exception => e
302
293
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
@@ -23,54 +23,101 @@ module Azure::ARM::Redis
23
23
  attr_reader :client
24
24
 
25
25
  #
26
- # Create a redis cache, or replace (overwrite/recreate, with potential
27
- # downtime) an existing cache
26
+ # Create or replace (overwrite/recreate, with potential downtime) an existing
27
+ # redis cache
28
28
  #
29
29
  # @param resource_group_name [String] The name of the resource group.
30
30
  # @param name [String] The name of the redis cache.
31
- # @param parameters [RedisCreateOrUpdateParameters] Parameters supplied to the
32
- # CreateOrUpdate redis operation.
31
+ # @param parameters [RedisCreateParameters] Parameters supplied to the Create
32
+ # redis operation.
33
33
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
34
34
  # will be added to the HTTP request.
35
35
  #
36
- # @return [RedisResourceWithAccessKey] operation results.
36
+ # @return [RedisResource] operation results.
37
+ #
38
+ def create(resource_group_name, name, parameters, custom_headers = nil)
39
+ response = create_async(resource_group_name, name, parameters, custom_headers).value!
40
+ response.body unless response.nil?
41
+ end
42
+
43
+ #
44
+ # @param resource_group_name [String] The name of the resource group.
45
+ # @param name [String] The name of the redis cache.
46
+ # @param parameters [RedisCreateParameters] Parameters supplied to the Create
47
+ # redis operation.
48
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
49
+ # will be added to the HTTP request.
50
+ #
51
+ # @return [Concurrent::Promise] promise which provides async access to http
52
+ # response.
53
+ #
54
+ def create_async(resource_group_name, name, parameters, custom_headers = nil)
55
+ # Send request
56
+ promise = begin_create_async(resource_group_name, name, parameters, custom_headers)
57
+
58
+ promise = promise.then do |response|
59
+ # Defining deserialization method.
60
+ deserialize_method = lambda do |parsed_response|
61
+ result_mapper = RedisResource.mapper()
62
+ parsed_response = @client.deserialize(result_mapper, parsed_response, 'parsed_response')
63
+ end
64
+
65
+ # Waiting for response.
66
+ @client.get_long_running_operation_result(response, deserialize_method)
67
+ end
68
+
69
+ promise
70
+ end
71
+
72
+ #
73
+ # Create or replace (overwrite/recreate, with potential downtime) an existing
74
+ # redis cache
75
+ #
76
+ # @param resource_group_name [String] The name of the resource group.
77
+ # @param name [String] The name of the redis cache.
78
+ # @param parameters [RedisCreateParameters] Parameters supplied to the Create
79
+ # redis operation.
80
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
81
+ # will be added to the HTTP request.
37
82
  #
38
- def create_or_update(resource_group_name, name, parameters, custom_headers = nil)
39
- response = create_or_update_async(resource_group_name, name, parameters, custom_headers).value!
83
+ # @return [RedisResource] operation results.
84
+ #
85
+ def begin_create(resource_group_name, name, parameters, custom_headers = nil)
86
+ response = begin_create_async(resource_group_name, name, parameters, custom_headers).value!
40
87
  response.body unless response.nil?
41
88
  end
42
89
 
43
90
  #
44
- # Create a redis cache, or replace (overwrite/recreate, with potential
45
- # downtime) an existing cache
91
+ # Create or replace (overwrite/recreate, with potential downtime) an existing
92
+ # redis cache
46
93
  #
47
94
  # @param resource_group_name [String] The name of the resource group.
48
95
  # @param name [String] The name of the redis cache.
49
- # @param parameters [RedisCreateOrUpdateParameters] Parameters supplied to the
50
- # CreateOrUpdate redis operation.
96
+ # @param parameters [RedisCreateParameters] Parameters supplied to the Create
97
+ # redis operation.
51
98
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
52
99
  # will be added to the HTTP request.
53
100
  #
54
101
  # @return [MsRestAzure::AzureOperationResponse] HTTP response information.
55
102
  #
56
- def create_or_update_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
57
- create_or_update_async(resource_group_name, name, parameters, custom_headers).value!
103
+ def begin_create_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
104
+ begin_create_async(resource_group_name, name, parameters, custom_headers).value!
58
105
  end
59
106
 
60
107
  #
61
- # Create a redis cache, or replace (overwrite/recreate, with potential
62
- # downtime) an existing cache
108
+ # Create or replace (overwrite/recreate, with potential downtime) an existing
109
+ # redis cache
63
110
  #
64
111
  # @param resource_group_name [String] The name of the resource group.
65
112
  # @param name [String] The name of the redis cache.
66
- # @param parameters [RedisCreateOrUpdateParameters] Parameters supplied to the
67
- # CreateOrUpdate redis operation.
113
+ # @param parameters [RedisCreateParameters] Parameters supplied to the Create
114
+ # redis operation.
68
115
  # @param [Hash{String => String}] A hash of custom headers that will be added
69
116
  # to the HTTP request.
70
117
  #
71
118
  # @return [Concurrent::Promise] Promise object which holds the HTTP response.
72
119
  #
73
- def create_or_update_async(resource_group_name, name, parameters, custom_headers = nil)
120
+ def begin_create_async(resource_group_name, name, parameters, custom_headers = nil)
74
121
  fail ArgumentError, 'resource_group_name is nil' if resource_group_name.nil?
75
122
  fail ArgumentError, 'name is nil' if name.nil?
76
123
  fail ArgumentError, 'parameters is nil' if parameters.nil?
@@ -87,52 +134,192 @@ module Azure::ARM::Redis
87
134
  request_headers['Content-Type'] = 'application/json; charset=utf-8'
88
135
 
89
136
  # Serialize Request
90
- request_mapper = RedisCreateOrUpdateParameters.mapper()
137
+ request_mapper = RedisCreateParameters.mapper()
91
138
  request_content = @client.serialize(request_mapper, parameters, 'parameters')
92
139
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
93
140
 
94
141
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}'
142
+
143
+ request_url = @base_url || @client.base_url
144
+
95
145
  options = {
96
146
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
97
147
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
98
148
  query_params: {'api-version' => @client.api_version},
99
149
  body: request_content,
100
- headers: request_headers.merge(custom_headers || {})
150
+ headers: request_headers.merge(custom_headers || {}),
151
+ base_url: request_url
101
152
  }
153
+ promise = @client.make_request_async(:put, path_template, options)
102
154
 
103
- request_url = @base_url || @client.base_url
104
-
105
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :put, options)
106
- promise = request.run_promise do |req|
107
- @client.credentials.sign_request(req) unless @client.credentials.nil?
108
- end
109
-
110
- promise = promise.then do |http_response|
155
+ promise = promise.then do |result|
156
+ http_response = result.response
111
157
  status_code = http_response.status
112
158
  response_content = http_response.body
113
159
  unless status_code == 201 || status_code == 200
114
160
  error_model = JSON.load(response_content)
115
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
161
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
116
162
  end
117
163
 
118
- # Create Result
119
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
120
164
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
121
165
  # Deserialize Response
122
- if status_code == 201
166
+ if status_code == 200
123
167
  begin
124
168
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
125
- result_mapper = RedisResourceWithAccessKey.mapper()
169
+ result_mapper = RedisResource.mapper()
126
170
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
127
171
  rescue Exception => e
128
172
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
129
173
  end
130
174
  end
175
+
176
+ result
177
+ end
178
+
179
+ promise.execute
180
+ end
181
+
182
+ #
183
+ # Update an existing Redis cache
184
+ #
185
+ # @param resource_group_name [String] The name of the resource group.
186
+ # @param name [String] The name of the redis cache.
187
+ # @param parameters [RedisUpdateParameters] Parameters supplied to the Update
188
+ # redis operation.
189
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
190
+ # will be added to the HTTP request.
191
+ #
192
+ # @return [RedisResource] operation results.
193
+ #
194
+ def update(resource_group_name, name, parameters, custom_headers = nil)
195
+ response = update_async(resource_group_name, name, parameters, custom_headers).value!
196
+ response.body unless response.nil?
197
+ end
198
+
199
+ #
200
+ # @param resource_group_name [String] The name of the resource group.
201
+ # @param name [String] The name of the redis cache.
202
+ # @param parameters [RedisUpdateParameters] Parameters supplied to the Update
203
+ # redis operation.
204
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
205
+ # will be added to the HTTP request.
206
+ #
207
+ # @return [Concurrent::Promise] promise which provides async access to http
208
+ # response.
209
+ #
210
+ def update_async(resource_group_name, name, parameters, custom_headers = nil)
211
+ # Send request
212
+ promise = begin_update_async(resource_group_name, name, parameters, custom_headers)
213
+
214
+ promise = promise.then do |response|
215
+ # Defining deserialization method.
216
+ deserialize_method = lambda do |parsed_response|
217
+ result_mapper = RedisResource.mapper()
218
+ parsed_response = @client.deserialize(result_mapper, parsed_response, 'parsed_response')
219
+ end
220
+
221
+ # Waiting for response.
222
+ @client.get_long_running_operation_result(response, deserialize_method)
223
+ end
224
+
225
+ promise
226
+ end
227
+
228
+ #
229
+ # Update an existing Redis cache
230
+ #
231
+ # @param resource_group_name [String] The name of the resource group.
232
+ # @param name [String] The name of the redis cache.
233
+ # @param parameters [RedisUpdateParameters] Parameters supplied to the Update
234
+ # redis operation.
235
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
236
+ # will be added to the HTTP request.
237
+ #
238
+ # @return [RedisResource] operation results.
239
+ #
240
+ def begin_update(resource_group_name, name, parameters, custom_headers = nil)
241
+ response = begin_update_async(resource_group_name, name, parameters, custom_headers).value!
242
+ response.body unless response.nil?
243
+ end
244
+
245
+ #
246
+ # Update an existing Redis cache
247
+ #
248
+ # @param resource_group_name [String] The name of the resource group.
249
+ # @param name [String] The name of the redis cache.
250
+ # @param parameters [RedisUpdateParameters] Parameters supplied to the Update
251
+ # redis operation.
252
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
253
+ # will be added to the HTTP request.
254
+ #
255
+ # @return [MsRestAzure::AzureOperationResponse] HTTP response information.
256
+ #
257
+ def begin_update_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
258
+ begin_update_async(resource_group_name, name, parameters, custom_headers).value!
259
+ end
260
+
261
+ #
262
+ # Update an existing Redis cache
263
+ #
264
+ # @param resource_group_name [String] The name of the resource group.
265
+ # @param name [String] The name of the redis cache.
266
+ # @param parameters [RedisUpdateParameters] Parameters supplied to the Update
267
+ # redis operation.
268
+ # @param [Hash{String => String}] A hash of custom headers that will be added
269
+ # to the HTTP request.
270
+ #
271
+ # @return [Concurrent::Promise] Promise object which holds the HTTP response.
272
+ #
273
+ def begin_update_async(resource_group_name, name, parameters, custom_headers = nil)
274
+ fail ArgumentError, 'resource_group_name is nil' if resource_group_name.nil?
275
+ fail ArgumentError, 'name is nil' if name.nil?
276
+ fail ArgumentError, 'parameters is nil' if parameters.nil?
277
+ fail ArgumentError, '@client.api_version is nil' if @client.api_version.nil?
278
+ fail ArgumentError, '@client.subscription_id is nil' if @client.subscription_id.nil?
279
+
280
+
281
+ request_headers = {}
282
+
283
+ # Set Headers
284
+ request_headers['x-ms-client-request-id'] = SecureRandom.uuid
285
+ request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
286
+
287
+ request_headers['Content-Type'] = 'application/json; charset=utf-8'
288
+
289
+ # Serialize Request
290
+ request_mapper = RedisUpdateParameters.mapper()
291
+ request_content = @client.serialize(request_mapper, parameters, 'parameters')
292
+ request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
293
+
294
+ path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}'
295
+
296
+ request_url = @base_url || @client.base_url
297
+
298
+ options = {
299
+ middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
300
+ path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
301
+ query_params: {'api-version' => @client.api_version},
302
+ body: request_content,
303
+ headers: request_headers.merge(custom_headers || {}),
304
+ base_url: request_url
305
+ }
306
+ promise = @client.make_request_async(:patch, path_template, options)
307
+
308
+ promise = promise.then do |result|
309
+ http_response = result.response
310
+ status_code = http_response.status
311
+ response_content = http_response.body
312
+ unless status_code == 200
313
+ error_model = JSON.load(response_content)
314
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
315
+ end
316
+
317
+ result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
131
318
  # Deserialize Response
132
319
  if status_code == 200
133
320
  begin
134
321
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
135
- result_mapper = RedisResourceWithAccessKey.mapper()
322
+ result_mapper = RedisResource.mapper()
136
323
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
137
324
  rescue Exception => e
138
325
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
@@ -153,12 +340,50 @@ module Azure::ARM::Redis
153
340
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
154
341
  # will be added to the HTTP request.
155
342
  #
156
- #
157
343
  def delete(resource_group_name, name, custom_headers = nil)
158
344
  response = delete_async(resource_group_name, name, custom_headers).value!
159
345
  nil
160
346
  end
161
347
 
348
+ #
349
+ # @param resource_group_name [String] The name of the resource group.
350
+ # @param name [String] The name of the redis cache.
351
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
352
+ # will be added to the HTTP request.
353
+ #
354
+ # @return [Concurrent::Promise] promise which provides async access to http
355
+ # response.
356
+ #
357
+ def delete_async(resource_group_name, name, custom_headers = nil)
358
+ # Send request
359
+ promise = begin_delete_async(resource_group_name, name, custom_headers)
360
+
361
+ promise = promise.then do |response|
362
+ # Defining deserialization method.
363
+ deserialize_method = lambda do |parsed_response|
364
+ end
365
+
366
+ # Waiting for response.
367
+ @client.get_long_running_operation_result(response, deserialize_method)
368
+ end
369
+
370
+ promise
371
+ end
372
+
373
+ #
374
+ # Deletes a redis cache. This operation takes a while to complete.
375
+ #
376
+ # @param resource_group_name [String] The name of the resource group.
377
+ # @param name [String] The name of the redis cache.
378
+ # @param custom_headers [Hash{String => String}] A hash of custom headers that
379
+ # will be added to the HTTP request.
380
+ #
381
+ #
382
+ def begin_delete(resource_group_name, name, custom_headers = nil)
383
+ response = begin_delete_async(resource_group_name, name, custom_headers).value!
384
+ nil
385
+ end
386
+
162
387
  #
163
388
  # Deletes a redis cache. This operation takes a while to complete.
164
389
  #
@@ -169,8 +394,8 @@ module Azure::ARM::Redis
169
394
  #
170
395
  # @return [MsRestAzure::AzureOperationResponse] HTTP response information.
171
396
  #
172
- def delete_with_http_info(resource_group_name, name, custom_headers = nil)
173
- delete_async(resource_group_name, name, custom_headers).value!
397
+ def begin_delete_with_http_info(resource_group_name, name, custom_headers = nil)
398
+ begin_delete_async(resource_group_name, name, custom_headers).value!
174
399
  end
175
400
 
176
401
  #
@@ -183,7 +408,7 @@ module Azure::ARM::Redis
183
408
  #
184
409
  # @return [Concurrent::Promise] Promise object which holds the HTTP response.
185
410
  #
186
- def delete_async(resource_group_name, name, custom_headers = nil)
411
+ def begin_delete_async(resource_group_name, name, custom_headers = nil)
187
412
  fail ArgumentError, 'resource_group_name is nil' if resource_group_name.nil?
188
413
  fail ArgumentError, 'name is nil' if name.nil?
189
414
  fail ArgumentError, '@client.api_version is nil' if @client.api_version.nil?
@@ -196,30 +421,27 @@ module Azure::ARM::Redis
196
421
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
197
422
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
198
423
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}'
424
+
425
+ request_url = @base_url || @client.base_url
426
+
199
427
  options = {
200
428
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
201
429
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
202
430
  query_params: {'api-version' => @client.api_version},
203
- headers: request_headers.merge(custom_headers || {})
431
+ headers: request_headers.merge(custom_headers || {}),
432
+ base_url: request_url
204
433
  }
434
+ promise = @client.make_request_async(:delete, path_template, options)
205
435
 
206
- request_url = @base_url || @client.base_url
207
-
208
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :delete, options)
209
- promise = request.run_promise do |req|
210
- @client.credentials.sign_request(req) unless @client.credentials.nil?
211
- end
212
-
213
- promise = promise.then do |http_response|
436
+ promise = promise.then do |result|
437
+ http_response = result.response
214
438
  status_code = http_response.status
215
439
  response_content = http_response.body
216
440
  unless status_code == 200 || status_code == 204
217
441
  error_model = JSON.load(response_content)
218
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
442
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
219
443
  end
220
444
 
221
- # Create Result
222
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
223
445
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
224
446
 
225
447
  result
@@ -280,30 +502,27 @@ module Azure::ARM::Redis
280
502
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
281
503
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
282
504
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}'
505
+
506
+ request_url = @base_url || @client.base_url
507
+
283
508
  options = {
284
509
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
285
510
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
286
511
  query_params: {'api-version' => @client.api_version},
287
- headers: request_headers.merge(custom_headers || {})
512
+ headers: request_headers.merge(custom_headers || {}),
513
+ base_url: request_url
288
514
  }
515
+ promise = @client.make_request_async(:get, path_template, options)
289
516
 
290
- request_url = @base_url || @client.base_url
291
-
292
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
293
- promise = request.run_promise do |req|
294
- @client.credentials.sign_request(req) unless @client.credentials.nil?
295
- end
296
-
297
- promise = promise.then do |http_response|
517
+ promise = promise.then do |result|
518
+ http_response = result.response
298
519
  status_code = http_response.status
299
520
  response_content = http_response.body
300
521
  unless status_code == 200
301
522
  error_model = JSON.load(response_content)
302
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
523
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
303
524
  end
304
525
 
305
- # Create Result
306
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
307
526
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
308
527
  # Deserialize Response
309
528
  if status_code == 200
@@ -335,8 +554,8 @@ module Azure::ARM::Redis
335
554
  response = list_by_resource_group_async(resource_group_name, custom_headers).value!
336
555
  unless response.nil?
337
556
  page = response.body
338
- page.next_method = Proc.new do |next_link|
339
- list_by_resource_group_next_async(next_link, custom_headers)
557
+ page.next_method = Proc.new do |next_page_link|
558
+ list_by_resource_group_next_async(next_page_link, custom_headers)
340
559
  end
341
560
  page
342
561
  end
@@ -390,30 +609,27 @@ module Azure::ARM::Redis
390
609
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
391
610
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
392
611
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/'
612
+
613
+ request_url = @base_url || @client.base_url
614
+
393
615
  options = {
394
616
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
395
617
  path_params: {'resourceGroupName' => resource_group_name,'subscriptionId' => @client.subscription_id},
396
618
  query_params: {'api-version' => @client.api_version},
397
- headers: request_headers.merge(custom_headers || {})
619
+ headers: request_headers.merge(custom_headers || {}),
620
+ base_url: request_url
398
621
  }
622
+ promise = @client.make_request_async(:get, path_template, options)
399
623
 
400
- request_url = @base_url || @client.base_url
401
-
402
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
403
- promise = request.run_promise do |req|
404
- @client.credentials.sign_request(req) unless @client.credentials.nil?
405
- end
406
-
407
- promise = promise.then do |http_response|
624
+ promise = promise.then do |result|
625
+ http_response = result.response
408
626
  status_code = http_response.status
409
627
  response_content = http_response.body
410
628
  unless status_code == 200
411
629
  error_model = JSON.load(response_content)
412
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
630
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
413
631
  end
414
632
 
415
- # Create Result
416
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
417
633
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
418
634
  # Deserialize Response
419
635
  if status_code == 200
@@ -444,8 +660,8 @@ module Azure::ARM::Redis
444
660
  response = list_async(custom_headers).value!
445
661
  unless response.nil?
446
662
  page = response.body
447
- page.next_method = Proc.new do |next_link|
448
- list_next_async(next_link, custom_headers)
663
+ page.next_method = Proc.new do |next_page_link|
664
+ list_next_async(next_page_link, custom_headers)
449
665
  end
450
666
  page
451
667
  end
@@ -495,30 +711,27 @@ module Azure::ARM::Redis
495
711
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
496
712
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
497
713
  path_template = '/subscriptions/{subscriptionId}/providers/Microsoft.Cache/Redis/'
714
+
715
+ request_url = @base_url || @client.base_url
716
+
498
717
  options = {
499
718
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
500
719
  path_params: {'subscriptionId' => @client.subscription_id},
501
720
  query_params: {'api-version' => @client.api_version},
502
- headers: request_headers.merge(custom_headers || {})
721
+ headers: request_headers.merge(custom_headers || {}),
722
+ base_url: request_url
503
723
  }
724
+ promise = @client.make_request_async(:get, path_template, options)
504
725
 
505
- request_url = @base_url || @client.base_url
506
-
507
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
508
- promise = request.run_promise do |req|
509
- @client.credentials.sign_request(req) unless @client.credentials.nil?
510
- end
511
-
512
- promise = promise.then do |http_response|
726
+ promise = promise.then do |result|
727
+ http_response = result.response
513
728
  status_code = http_response.status
514
729
  response_content = http_response.body
515
730
  unless status_code == 200
516
731
  error_model = JSON.load(response_content)
517
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
732
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
518
733
  end
519
734
 
520
- # Create Result
521
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
522
735
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
523
736
  # Deserialize Response
524
737
  if status_code == 200
@@ -546,7 +759,7 @@ module Azure::ARM::Redis
546
759
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
547
760
  # will be added to the HTTP request.
548
761
  #
549
- # @return [RedisListKeysResult] operation results.
762
+ # @return [RedisAccessKeys] operation results.
550
763
  #
551
764
  def list_keys(resource_group_name, name, custom_headers = nil)
552
765
  response = list_keys_async(resource_group_name, name, custom_headers).value!
@@ -592,36 +805,33 @@ module Azure::ARM::Redis
592
805
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
593
806
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
594
807
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/listKeys'
808
+
809
+ request_url = @base_url || @client.base_url
810
+
595
811
  options = {
596
812
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
597
813
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
598
814
  query_params: {'api-version' => @client.api_version},
599
- headers: request_headers.merge(custom_headers || {})
815
+ headers: request_headers.merge(custom_headers || {}),
816
+ base_url: request_url
600
817
  }
818
+ promise = @client.make_request_async(:post, path_template, options)
601
819
 
602
- request_url = @base_url || @client.base_url
603
-
604
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :post, options)
605
- promise = request.run_promise do |req|
606
- @client.credentials.sign_request(req) unless @client.credentials.nil?
607
- end
608
-
609
- promise = promise.then do |http_response|
820
+ promise = promise.then do |result|
821
+ http_response = result.response
610
822
  status_code = http_response.status
611
823
  response_content = http_response.body
612
824
  unless status_code == 200
613
825
  error_model = JSON.load(response_content)
614
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
826
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
615
827
  end
616
828
 
617
- # Create Result
618
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
619
829
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
620
830
  # Deserialize Response
621
831
  if status_code == 200
622
832
  begin
623
833
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
624
- result_mapper = RedisListKeysResult.mapper()
834
+ result_mapper = RedisAccessKeys.mapper()
625
835
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
626
836
  rescue Exception => e
627
837
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
@@ -645,7 +855,7 @@ module Azure::ARM::Redis
645
855
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
646
856
  # will be added to the HTTP request.
647
857
  #
648
- # @return [RedisListKeysResult] operation results.
858
+ # @return [RedisAccessKeys] operation results.
649
859
  #
650
860
  def regenerate_key(resource_group_name, name, parameters, custom_headers = nil)
651
861
  response = regenerate_key_async(resource_group_name, name, parameters, custom_headers).value!
@@ -704,37 +914,34 @@ module Azure::ARM::Redis
704
914
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
705
915
 
706
916
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/regenerateKey'
917
+
918
+ request_url = @base_url || @client.base_url
919
+
707
920
  options = {
708
921
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
709
922
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
710
923
  query_params: {'api-version' => @client.api_version},
711
924
  body: request_content,
712
- headers: request_headers.merge(custom_headers || {})
925
+ headers: request_headers.merge(custom_headers || {}),
926
+ base_url: request_url
713
927
  }
928
+ promise = @client.make_request_async(:post, path_template, options)
714
929
 
715
- request_url = @base_url || @client.base_url
716
-
717
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :post, options)
718
- promise = request.run_promise do |req|
719
- @client.credentials.sign_request(req) unless @client.credentials.nil?
720
- end
721
-
722
- promise = promise.then do |http_response|
930
+ promise = promise.then do |result|
931
+ http_response = result.response
723
932
  status_code = http_response.status
724
933
  response_content = http_response.body
725
934
  unless status_code == 200
726
935
  error_model = JSON.load(response_content)
727
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
936
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
728
937
  end
729
938
 
730
- # Create Result
731
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
732
939
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
733
940
  # Deserialize Response
734
941
  if status_code == 200
735
942
  begin
736
943
  parsed_response = response_content.to_s.empty? ? nil : JSON.load(response_content)
737
- result_mapper = RedisListKeysResult.mapper()
944
+ result_mapper = RedisAccessKeys.mapper()
738
945
  result.body = @client.deserialize(result_mapper, parsed_response, 'result.body')
739
946
  rescue Exception => e
740
947
  fail MsRest::DeserializationError.new('Error occurred in deserializing the response', e.message, e.backtrace, result)
@@ -816,31 +1023,28 @@ module Azure::ARM::Redis
816
1023
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
817
1024
 
818
1025
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/forceReboot'
1026
+
1027
+ request_url = @base_url || @client.base_url
1028
+
819
1029
  options = {
820
1030
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
821
1031
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
822
1032
  query_params: {'api-version' => @client.api_version},
823
1033
  body: request_content,
824
- headers: request_headers.merge(custom_headers || {})
1034
+ headers: request_headers.merge(custom_headers || {}),
1035
+ base_url: request_url
825
1036
  }
1037
+ promise = @client.make_request_async(:post, path_template, options)
826
1038
 
827
- request_url = @base_url || @client.base_url
828
-
829
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :post, options)
830
- promise = request.run_promise do |req|
831
- @client.credentials.sign_request(req) unless @client.credentials.nil?
832
- end
833
-
834
- promise = promise.then do |http_response|
1039
+ promise = promise.then do |result|
1040
+ http_response = result.response
835
1041
  status_code = http_response.status
836
1042
  response_content = http_response.body
837
1043
  unless status_code == 200 || status_code == 204
838
1044
  error_model = JSON.load(response_content)
839
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
1045
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
840
1046
  end
841
1047
 
842
- # Create Result
843
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
844
1048
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
845
1049
 
846
1050
  result
@@ -859,8 +1063,8 @@ module Azure::ARM::Redis
859
1063
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
860
1064
  # will be added to the HTTP request.
861
1065
  #
862
- def import(resource_group_name, name, parameters, custom_headers = nil)
863
- response = import_async(resource_group_name, name, parameters, custom_headers).value!
1066
+ def import_data(resource_group_name, name, parameters, custom_headers = nil)
1067
+ response = import_data_async(resource_group_name, name, parameters, custom_headers).value!
864
1068
  nil
865
1069
  end
866
1070
 
@@ -875,9 +1079,9 @@ module Azure::ARM::Redis
875
1079
  # @return [Concurrent::Promise] promise which provides async access to http
876
1080
  # response.
877
1081
  #
878
- def import_async(resource_group_name, name, parameters, custom_headers = nil)
1082
+ def import_data_async(resource_group_name, name, parameters, custom_headers = nil)
879
1083
  # Send request
880
- promise = begin_import_async(resource_group_name, name, parameters, custom_headers)
1084
+ promise = begin_import_data_async(resource_group_name, name, parameters, custom_headers)
881
1085
 
882
1086
  promise = promise.then do |response|
883
1087
  # Defining deserialization method.
@@ -902,8 +1106,8 @@ module Azure::ARM::Redis
902
1106
  # will be added to the HTTP request.
903
1107
  #
904
1108
  #
905
- def begin_import(resource_group_name, name, parameters, custom_headers = nil)
906
- response = begin_import_async(resource_group_name, name, parameters, custom_headers).value!
1109
+ def begin_import_data(resource_group_name, name, parameters, custom_headers = nil)
1110
+ response = begin_import_data_async(resource_group_name, name, parameters, custom_headers).value!
907
1111
  nil
908
1112
  end
909
1113
 
@@ -919,8 +1123,8 @@ module Azure::ARM::Redis
919
1123
  #
920
1124
  # @return [MsRestAzure::AzureOperationResponse] HTTP response information.
921
1125
  #
922
- def begin_import_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
923
- begin_import_async(resource_group_name, name, parameters, custom_headers).value!
1126
+ def begin_import_data_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
1127
+ begin_import_data_async(resource_group_name, name, parameters, custom_headers).value!
924
1128
  end
925
1129
 
926
1130
  #
@@ -935,7 +1139,7 @@ module Azure::ARM::Redis
935
1139
  #
936
1140
  # @return [Concurrent::Promise] Promise object which holds the HTTP response.
937
1141
  #
938
- def begin_import_async(resource_group_name, name, parameters, custom_headers = nil)
1142
+ def begin_import_data_async(resource_group_name, name, parameters, custom_headers = nil)
939
1143
  fail ArgumentError, 'resource_group_name is nil' if resource_group_name.nil?
940
1144
  fail ArgumentError, 'name is nil' if name.nil?
941
1145
  fail ArgumentError, 'parameters is nil' if parameters.nil?
@@ -957,31 +1161,28 @@ module Azure::ARM::Redis
957
1161
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
958
1162
 
959
1163
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/import'
1164
+
1165
+ request_url = @base_url || @client.base_url
1166
+
960
1167
  options = {
961
1168
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
962
1169
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
963
1170
  query_params: {'api-version' => @client.api_version},
964
1171
  body: request_content,
965
- headers: request_headers.merge(custom_headers || {})
1172
+ headers: request_headers.merge(custom_headers || {}),
1173
+ base_url: request_url
966
1174
  }
1175
+ promise = @client.make_request_async(:post, path_template, options)
967
1176
 
968
- request_url = @base_url || @client.base_url
969
-
970
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :post, options)
971
- promise = request.run_promise do |req|
972
- @client.credentials.sign_request(req) unless @client.credentials.nil?
973
- end
974
-
975
- promise = promise.then do |http_response|
1177
+ promise = promise.then do |result|
1178
+ http_response = result.response
976
1179
  status_code = http_response.status
977
1180
  response_content = http_response.body
978
1181
  unless status_code == 202
979
1182
  error_model = JSON.load(response_content)
980
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
1183
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
981
1184
  end
982
1185
 
983
- # Create Result
984
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
985
1186
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
986
1187
 
987
1188
  result
@@ -1000,8 +1201,8 @@ module Azure::ARM::Redis
1000
1201
  # @param custom_headers [Hash{String => String}] A hash of custom headers that
1001
1202
  # will be added to the HTTP request.
1002
1203
  #
1003
- def export(resource_group_name, name, parameters, custom_headers = nil)
1004
- response = export_async(resource_group_name, name, parameters, custom_headers).value!
1204
+ def export_data(resource_group_name, name, parameters, custom_headers = nil)
1205
+ response = export_data_async(resource_group_name, name, parameters, custom_headers).value!
1005
1206
  nil
1006
1207
  end
1007
1208
 
@@ -1016,9 +1217,9 @@ module Azure::ARM::Redis
1016
1217
  # @return [Concurrent::Promise] promise which provides async access to http
1017
1218
  # response.
1018
1219
  #
1019
- def export_async(resource_group_name, name, parameters, custom_headers = nil)
1220
+ def export_data_async(resource_group_name, name, parameters, custom_headers = nil)
1020
1221
  # Send request
1021
- promise = begin_export_async(resource_group_name, name, parameters, custom_headers)
1222
+ promise = begin_export_data_async(resource_group_name, name, parameters, custom_headers)
1022
1223
 
1023
1224
  promise = promise.then do |response|
1024
1225
  # Defining deserialization method.
@@ -1043,8 +1244,8 @@ module Azure::ARM::Redis
1043
1244
  # will be added to the HTTP request.
1044
1245
  #
1045
1246
  #
1046
- def begin_export(resource_group_name, name, parameters, custom_headers = nil)
1047
- response = begin_export_async(resource_group_name, name, parameters, custom_headers).value!
1247
+ def begin_export_data(resource_group_name, name, parameters, custom_headers = nil)
1248
+ response = begin_export_data_async(resource_group_name, name, parameters, custom_headers).value!
1048
1249
  nil
1049
1250
  end
1050
1251
 
@@ -1060,8 +1261,8 @@ module Azure::ARM::Redis
1060
1261
  #
1061
1262
  # @return [MsRestAzure::AzureOperationResponse] HTTP response information.
1062
1263
  #
1063
- def begin_export_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
1064
- begin_export_async(resource_group_name, name, parameters, custom_headers).value!
1264
+ def begin_export_data_with_http_info(resource_group_name, name, parameters, custom_headers = nil)
1265
+ begin_export_data_async(resource_group_name, name, parameters, custom_headers).value!
1065
1266
  end
1066
1267
 
1067
1268
  #
@@ -1076,7 +1277,7 @@ module Azure::ARM::Redis
1076
1277
  #
1077
1278
  # @return [Concurrent::Promise] Promise object which holds the HTTP response.
1078
1279
  #
1079
- def begin_export_async(resource_group_name, name, parameters, custom_headers = nil)
1280
+ def begin_export_data_async(resource_group_name, name, parameters, custom_headers = nil)
1080
1281
  fail ArgumentError, 'resource_group_name is nil' if resource_group_name.nil?
1081
1282
  fail ArgumentError, 'name is nil' if name.nil?
1082
1283
  fail ArgumentError, 'parameters is nil' if parameters.nil?
@@ -1098,31 +1299,28 @@ module Azure::ARM::Redis
1098
1299
  request_content = request_content != nil ? JSON.generate(request_content, quirks_mode: true) : nil
1099
1300
 
1100
1301
  path_template = '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Cache/Redis/{name}/export'
1302
+
1303
+ request_url = @base_url || @client.base_url
1304
+
1101
1305
  options = {
1102
1306
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
1103
1307
  path_params: {'resourceGroupName' => resource_group_name,'name' => name,'subscriptionId' => @client.subscription_id},
1104
1308
  query_params: {'api-version' => @client.api_version},
1105
1309
  body: request_content,
1106
- headers: request_headers.merge(custom_headers || {})
1310
+ headers: request_headers.merge(custom_headers || {}),
1311
+ base_url: request_url
1107
1312
  }
1313
+ promise = @client.make_request_async(:post, path_template, options)
1108
1314
 
1109
- request_url = @base_url || @client.base_url
1110
-
1111
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :post, options)
1112
- promise = request.run_promise do |req|
1113
- @client.credentials.sign_request(req) unless @client.credentials.nil?
1114
- end
1115
-
1116
- promise = promise.then do |http_response|
1315
+ promise = promise.then do |result|
1316
+ http_response = result.response
1117
1317
  status_code = http_response.status
1118
1318
  response_content = http_response.body
1119
1319
  unless status_code == 202
1120
1320
  error_model = JSON.load(response_content)
1121
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
1321
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
1122
1322
  end
1123
1323
 
1124
- # Create Result
1125
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
1126
1324
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
1127
1325
 
1128
1326
  result
@@ -1180,29 +1378,26 @@ module Azure::ARM::Redis
1180
1378
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
1181
1379
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
1182
1380
  path_template = '{nextLink}'
1381
+
1382
+ request_url = @base_url || @client.base_url
1383
+
1183
1384
  options = {
1184
1385
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
1185
1386
  skip_encoding_path_params: {'nextLink' => next_page_link},
1186
- headers: request_headers.merge(custom_headers || {})
1387
+ headers: request_headers.merge(custom_headers || {}),
1388
+ base_url: request_url
1187
1389
  }
1390
+ promise = @client.make_request_async(:get, path_template, options)
1188
1391
 
1189
- request_url = @base_url || @client.base_url
1190
-
1191
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
1192
- promise = request.run_promise do |req|
1193
- @client.credentials.sign_request(req) unless @client.credentials.nil?
1194
- end
1195
-
1196
- promise = promise.then do |http_response|
1392
+ promise = promise.then do |result|
1393
+ http_response = result.response
1197
1394
  status_code = http_response.status
1198
1395
  response_content = http_response.body
1199
1396
  unless status_code == 200
1200
1397
  error_model = JSON.load(response_content)
1201
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
1398
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
1202
1399
  end
1203
1400
 
1204
- # Create Result
1205
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
1206
1401
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
1207
1402
  # Deserialize Response
1208
1403
  if status_code == 200
@@ -1270,29 +1465,26 @@ module Azure::ARM::Redis
1270
1465
  request_headers['x-ms-client-request-id'] = SecureRandom.uuid
1271
1466
  request_headers['accept-language'] = @client.accept_language unless @client.accept_language.nil?
1272
1467
  path_template = '{nextLink}'
1468
+
1469
+ request_url = @base_url || @client.base_url
1470
+
1273
1471
  options = {
1274
1472
  middlewares: [[MsRest::RetryPolicyMiddleware, times: 3, retry: 0.02], [:cookie_jar]],
1275
1473
  skip_encoding_path_params: {'nextLink' => next_page_link},
1276
- headers: request_headers.merge(custom_headers || {})
1474
+ headers: request_headers.merge(custom_headers || {}),
1475
+ base_url: request_url
1277
1476
  }
1477
+ promise = @client.make_request_async(:get, path_template, options)
1278
1478
 
1279
- request_url = @base_url || @client.base_url
1280
-
1281
- request = MsRest::HttpOperationRequest.new(request_url, path_template, :get, options)
1282
- promise = request.run_promise do |req|
1283
- @client.credentials.sign_request(req) unless @client.credentials.nil?
1284
- end
1285
-
1286
- promise = promise.then do |http_response|
1479
+ promise = promise.then do |result|
1480
+ http_response = result.response
1287
1481
  status_code = http_response.status
1288
1482
  response_content = http_response.body
1289
1483
  unless status_code == 200
1290
1484
  error_model = JSON.load(response_content)
1291
- fail MsRestAzure::AzureOperationError.new(request, http_response, error_model)
1485
+ fail MsRestAzure::AzureOperationError.new(result.request, http_response, error_model)
1292
1486
  end
1293
1487
 
1294
- # Create Result
1295
- result = MsRestAzure::AzureOperationResponse.new(request, http_response)
1296
1488
  result.request_id = http_response['x-ms-request-id'] unless http_response['x-ms-request-id'].nil?
1297
1489
  # Deserialize Response
1298
1490
  if status_code == 200