azure_mgmt_redis 0.6.0 → 0.7.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -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