Shortcuts on this page
r m x toggle line displays
j k next/prev highlighted chunk
0 (zero) top of page
1 (one) first highlighted chunk
1# pylint: disable=line-too-long,useless-suppression,too-many-lines
2# coding=utf-8
3# --------------------------------------------------------------------------
4# Copyright (c) Microsoft Corporation. All rights reserved.
5# Licensed under the MIT License. See License.txt in the project root for license information.
6# Code generated by Microsoft (R) Python Code Generator.
7# Changes may cause incorrect behavior and will be lost if the code is regenerated.
8# --------------------------------------------------------------------------
9from collections.abc import MutableMapping
10from io import IOBase
11import json
12from typing import Any, Callable, IO, Iterator, Optional, TypeVar, Union, cast, overload
13import urllib.parse
15from azure.core import PipelineClient
16from azure.core.exceptions import (
17 ClientAuthenticationError,
18 HttpResponseError,
19 ResourceExistsError,
20 ResourceNotFoundError,
21 ResourceNotModifiedError,
22 StreamClosedError,
23 StreamConsumedError,
24 map_error,
25)
26from azure.core.paging import ItemPaged
27from azure.core.pipeline import PipelineResponse
28from azure.core.polling import LROPoller, NoPolling, PollingMethod
29from azure.core.rest import HttpRequest, HttpResponse
30from azure.core.tracing.decorator import distributed_trace
31from azure.core.utils import case_insensitive_dict
32from azure.mgmt.core.exceptions import ARMErrorFormat
33from azure.mgmt.core.polling.arm_polling import ARMPolling
35from .. import models as _models, types as _types
36from .._configuration import DynatraceObservabilityMgmtClientConfiguration
37from .._utils.model_base import SdkJSONEncoder, _deserialize, _failsafe_deserialize
38from .._utils.serialization import Deserializer, Serializer
40T = TypeVar("T")
41ClsType = Optional[Callable[[PipelineResponse[HttpRequest, HttpResponse], T, dict[str, Any]], Any]]
42List = list
44_SERIALIZER = Serializer()
45_SERIALIZER.client_side_validation = False
48def build_operations_list_request(**kwargs: Any) -> HttpRequest:
49 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
50 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
52 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
53 accept = _headers.pop("Accept", "application/json")
55 # Construct URL
56 _url = "/providers/Dynatrace.Observability/operations"
58 # Construct parameters
59 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
61 # Construct headers
62 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
64 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
67def build_monitored_subscriptions_get_request( # pylint: disable=name-too-long
68 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
69) -> HttpRequest:
70 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
71 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
73 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
74 accept = _headers.pop("Accept", "application/json")
76 # Construct URL
77 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/monitoredSubscriptions/default"
78 path_format_arguments = {
79 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
80 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
81 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
82 }
84 _url: str = _url.format(**path_format_arguments) # type: ignore
86 # Construct parameters
87 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
89 # Construct headers
90 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
92 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
95def build_monitored_subscriptions_create_or_update_request( # pylint: disable=name-too-long
96 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
97) -> HttpRequest:
98 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
99 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
101 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
102 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
103 accept = _headers.pop("Accept", "application/json")
105 # Construct URL
106 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/monitoredSubscriptions/default"
107 path_format_arguments = {
108 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
109 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
110 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
111 }
113 _url: str = _url.format(**path_format_arguments) # type: ignore
115 # Construct parameters
116 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
118 # Construct headers
119 if content_type is not None:
120 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
121 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
123 return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
126def build_monitored_subscriptions_update_request( # pylint: disable=name-too-long
127 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
128) -> HttpRequest:
129 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
130 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
132 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
133 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
134 accept = _headers.pop("Accept", "application/json")
136 # Construct URL
137 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/monitoredSubscriptions/default"
138 path_format_arguments = {
139 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
140 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
141 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
142 }
144 _url: str = _url.format(**path_format_arguments) # type: ignore
146 # Construct parameters
147 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
149 # Construct headers
150 if content_type is not None:
151 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
152 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
154 return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
157def build_monitored_subscriptions_delete_request( # pylint: disable=name-too-long
158 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
159) -> HttpRequest:
160 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
162 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
163 # Construct URL
164 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/monitoredSubscriptions/default"
165 path_format_arguments = {
166 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
167 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
168 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
169 }
171 _url: str = _url.format(**path_format_arguments) # type: ignore
173 # Construct parameters
174 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
176 return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs)
179def build_monitored_subscriptions_list_request( # pylint: disable=name-too-long
180 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
181) -> HttpRequest:
182 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
183 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
185 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
186 accept = _headers.pop("Accept", "application/json")
188 # Construct URL
189 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/monitoredSubscriptions"
190 path_format_arguments = {
191 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
192 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
193 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
194 }
196 _url: str = _url.format(**path_format_arguments) # type: ignore
198 # Construct parameters
199 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
201 # Construct headers
202 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
204 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
207def build_tag_rules_get_request(
208 resource_group_name: str, monitor_name: str, rule_set_name: str, subscription_id: str, **kwargs: Any
209) -> HttpRequest:
210 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
211 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
213 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
214 accept = _headers.pop("Accept", "application/json")
216 # Construct URL
217 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/tagRules/{ruleSetName}"
218 path_format_arguments = {
219 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
220 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
221 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
222 "ruleSetName": _SERIALIZER.url("rule_set_name", rule_set_name, "str"),
223 }
225 _url: str = _url.format(**path_format_arguments) # type: ignore
227 # Construct parameters
228 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
230 # Construct headers
231 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
233 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
236def build_tag_rules_create_or_update_request(
237 resource_group_name: str, monitor_name: str, rule_set_name: str, subscription_id: str, **kwargs: Any
238) -> HttpRequest:
239 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
240 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
242 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
243 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
244 accept = _headers.pop("Accept", "application/json")
246 # Construct URL
247 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/tagRules/{ruleSetName}"
248 path_format_arguments = {
249 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
250 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
251 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
252 "ruleSetName": _SERIALIZER.url("rule_set_name", rule_set_name, "str"),
253 }
255 _url: str = _url.format(**path_format_arguments) # type: ignore
257 # Construct parameters
258 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
260 # Construct headers
261 if content_type is not None:
262 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
263 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
265 return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
268def build_tag_rules_delete_request(
269 resource_group_name: str, monitor_name: str, rule_set_name: str, subscription_id: str, **kwargs: Any
270) -> HttpRequest:
271 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
273 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
274 # Construct URL
275 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/tagRules/{ruleSetName}"
276 path_format_arguments = {
277 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
278 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
279 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
280 "ruleSetName": _SERIALIZER.url("rule_set_name", rule_set_name, "str"),
281 }
283 _url: str = _url.format(**path_format_arguments) # type: ignore
285 # Construct parameters
286 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
288 return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs)
291def build_tag_rules_list_request(
292 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
293) -> HttpRequest:
294 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
295 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
297 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
298 accept = _headers.pop("Accept", "application/json")
300 # Construct URL
301 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/tagRules"
302 path_format_arguments = {
303 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
304 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
305 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
306 }
308 _url: str = _url.format(**path_format_arguments) # type: ignore
310 # Construct parameters
311 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
313 # Construct headers
314 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
316 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
319def build_monitors_get_request(
320 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
321) -> HttpRequest:
322 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
323 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
325 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
326 accept = _headers.pop("Accept", "application/json")
328 # Construct URL
329 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}"
330 path_format_arguments = {
331 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
332 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
333 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
334 }
336 _url: str = _url.format(**path_format_arguments) # type: ignore
338 # Construct parameters
339 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
341 # Construct headers
342 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
344 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
347def build_monitors_create_or_update_request(
348 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
349) -> HttpRequest:
350 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
351 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
353 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
354 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
355 accept = _headers.pop("Accept", "application/json")
357 # Construct URL
358 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}"
359 path_format_arguments = {
360 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
361 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
362 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
363 }
365 _url: str = _url.format(**path_format_arguments) # type: ignore
367 # Construct parameters
368 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
370 # Construct headers
371 if content_type is not None:
372 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
373 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
375 return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
378def build_monitors_update_request(
379 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
380) -> HttpRequest:
381 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
382 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
384 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
385 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
386 accept = _headers.pop("Accept", "application/json")
388 # Construct URL
389 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}"
390 path_format_arguments = {
391 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
392 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
393 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
394 }
396 _url: str = _url.format(**path_format_arguments) # type: ignore
398 # Construct parameters
399 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
401 # Construct headers
402 if content_type is not None:
403 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
404 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
406 return HttpRequest(method="PATCH", url=_url, params=_params, headers=_headers, **kwargs)
409def build_monitors_delete_request(
410 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
411) -> HttpRequest:
412 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
414 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
415 # Construct URL
416 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}"
417 path_format_arguments = {
418 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
419 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
420 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
421 }
423 _url: str = _url.format(**path_format_arguments) # type: ignore
425 # Construct parameters
426 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
428 return HttpRequest(method="DELETE", url=_url, params=_params, **kwargs)
431def build_monitors_list_by_resource_group_request( # pylint: disable=name-too-long
432 resource_group_name: str, subscription_id: str, **kwargs: Any
433) -> HttpRequest:
434 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
435 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
437 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
438 accept = _headers.pop("Accept", "application/json")
440 # Construct URL
441 _url = (
442 "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors"
443 )
444 path_format_arguments = {
445 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
446 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
447 }
449 _url: str = _url.format(**path_format_arguments) # type: ignore
451 # Construct parameters
452 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
454 # Construct headers
455 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
457 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
460def build_monitors_list_by_subscription_id_request( # pylint: disable=name-too-long
461 subscription_id: str, **kwargs: Any
462) -> HttpRequest:
463 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
464 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
466 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
467 accept = _headers.pop("Accept", "application/json")
469 # Construct URL
470 _url = "/subscriptions/{subscriptionId}/providers/Dynatrace.Observability/monitors"
471 path_format_arguments = {
472 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
473 }
475 _url: str = _url.format(**path_format_arguments) # type: ignore
477 # Construct parameters
478 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
480 # Construct headers
481 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
483 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
486def build_monitors_list_monitored_resources_request( # pylint: disable=name-too-long
487 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
488) -> HttpRequest:
489 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
490 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
492 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
493 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
494 accept = _headers.pop("Accept", "application/json")
496 # Construct URL
497 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/listMonitoredResources"
498 path_format_arguments = {
499 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
500 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
501 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
502 }
504 _url: str = _url.format(**path_format_arguments) # type: ignore
506 # Construct parameters
507 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
509 # Construct headers
510 if content_type is not None:
511 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
512 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
514 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
517def build_monitors_get_vm_host_payload_request( # pylint: disable=name-too-long
518 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
519) -> HttpRequest:
520 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
521 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
523 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
524 accept = _headers.pop("Accept", "application/json")
526 # Construct URL
527 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/getVMHostPayload"
528 path_format_arguments = {
529 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
530 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
531 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
532 }
534 _url: str = _url.format(**path_format_arguments) # type: ignore
536 # Construct parameters
537 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
539 # Construct headers
540 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
542 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
545def build_monitors_manage_agent_installation_request( # pylint: disable=name-too-long
546 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
547) -> HttpRequest:
548 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
549 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
551 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
552 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
553 # Construct URL
554 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/manageAgentInstallation"
555 path_format_arguments = {
556 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
557 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
558 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
559 }
561 _url: str = _url.format(**path_format_arguments) # type: ignore
563 # Construct parameters
564 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
566 # Construct headers
567 if content_type is not None:
568 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
570 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
573def build_monitors_list_hosts_request(
574 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
575) -> HttpRequest:
576 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
577 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
579 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
580 accept = _headers.pop("Accept", "application/json")
582 # Construct URL
583 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/listHosts"
584 path_format_arguments = {
585 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
586 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
587 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
588 }
590 _url: str = _url.format(**path_format_arguments) # type: ignore
592 # Construct parameters
593 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
595 # Construct headers
596 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
598 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
601def build_monitors_get_metric_status_request(
602 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
603) -> HttpRequest:
604 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
605 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
607 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
608 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
609 accept = _headers.pop("Accept", "application/json")
611 # Construct URL
612 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/getMetricStatus"
613 path_format_arguments = {
614 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
615 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
616 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
617 }
619 _url: str = _url.format(**path_format_arguments) # type: ignore
621 # Construct parameters
622 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
624 # Construct headers
625 if content_type is not None:
626 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
627 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
629 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
632def build_monitors_list_app_services_request(
633 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
634) -> HttpRequest:
635 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
636 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
638 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
639 accept = _headers.pop("Accept", "application/json")
641 # Construct URL
642 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/listAppServices"
643 path_format_arguments = {
644 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
645 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
646 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
647 }
649 _url: str = _url.format(**path_format_arguments) # type: ignore
651 # Construct parameters
652 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
654 # Construct headers
655 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
657 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
660def build_monitors_upgrade_plan_request(
661 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
662) -> HttpRequest:
663 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
664 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
666 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
667 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
668 # Construct URL
669 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/upgradePlan"
670 path_format_arguments = {
671 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
672 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
673 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
674 }
676 _url: str = _url.format(**path_format_arguments) # type: ignore
678 # Construct parameters
679 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
681 # Construct headers
682 if content_type is not None:
683 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
685 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
688def build_monitors_get_sso_details_request(
689 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
690) -> HttpRequest:
691 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
692 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
694 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
695 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
696 accept = _headers.pop("Accept", "application/json")
698 # Construct URL
699 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/getSSODetails"
700 path_format_arguments = {
701 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
702 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
703 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
704 }
706 _url: str = _url.format(**path_format_arguments) # type: ignore
708 # Construct parameters
709 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
711 # Construct headers
712 if content_type is not None:
713 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
714 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
716 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
719def build_monitors_list_linkable_environments_request( # pylint: disable=name-too-long
720 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
721) -> HttpRequest:
722 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
723 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
725 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
726 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
727 accept = _headers.pop("Accept", "application/json")
729 # Construct URL
730 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/listLinkableEnvironments"
731 path_format_arguments = {
732 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
733 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
734 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
735 }
737 _url: str = _url.format(**path_format_arguments) # type: ignore
739 # Construct parameters
740 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
742 # Construct headers
743 if content_type is not None:
744 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
745 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
747 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
750def build_monitors_get_all_connected_resources_count_request( # pylint: disable=name-too-long
751 subscription_id: str, **kwargs: Any
752) -> HttpRequest:
753 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
754 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
756 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
757 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
758 accept = _headers.pop("Accept", "application/json")
760 # Construct URL
761 _url = "/subscriptions/{subscriptionId}/providers/Dynatrace.Observability/getAllConnectedResourcesCount"
762 path_format_arguments = {
763 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
764 }
766 _url: str = _url.format(**path_format_arguments) # type: ignore
768 # Construct parameters
769 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
771 # Construct headers
772 if content_type is not None:
773 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
774 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
776 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
779def build_monitors_get_marketplace_saa_s_resource_details_request( # pylint: disable=name-too-long
780 subscription_id: str, **kwargs: Any
781) -> HttpRequest:
782 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
783 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
785 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
786 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
787 accept = _headers.pop("Accept", "application/json")
789 # Construct URL
790 _url = "/subscriptions/{subscriptionId}/providers/Dynatrace.Observability/getMarketplaceSaaSResourceDetails"
791 path_format_arguments = {
792 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
793 }
795 _url: str = _url.format(**path_format_arguments) # type: ignore
797 # Construct parameters
798 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
800 # Construct headers
801 if content_type is not None:
802 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
803 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
805 return HttpRequest(method="POST", url=_url, params=_params, headers=_headers, **kwargs)
808def build_single_sign_on_get_request(
809 resource_group_name: str, monitor_name: str, configuration_name: str, subscription_id: str, **kwargs: Any
810) -> HttpRequest:
811 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
812 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
814 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
815 accept = _headers.pop("Accept", "application/json")
817 # Construct URL
818 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/singleSignOnConfigurations/{configurationName}"
819 path_format_arguments = {
820 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
821 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
822 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
823 "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"),
824 }
826 _url: str = _url.format(**path_format_arguments) # type: ignore
828 # Construct parameters
829 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
831 # Construct headers
832 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
834 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
837def build_single_sign_on_create_or_update_request( # pylint: disable=name-too-long
838 resource_group_name: str, monitor_name: str, configuration_name: str, subscription_id: str, **kwargs: Any
839) -> HttpRequest:
840 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
841 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
843 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
844 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
845 accept = _headers.pop("Accept", "application/json")
847 # Construct URL
848 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/singleSignOnConfigurations/{configurationName}"
849 path_format_arguments = {
850 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
851 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
852 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
853 "configurationName": _SERIALIZER.url("configuration_name", configuration_name, "str"),
854 }
856 _url: str = _url.format(**path_format_arguments) # type: ignore
858 # Construct parameters
859 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
861 # Construct headers
862 if content_type is not None:
863 _headers["Content-Type"] = _SERIALIZER.header("content_type", content_type, "str")
864 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
866 return HttpRequest(method="PUT", url=_url, params=_params, headers=_headers, **kwargs)
869def build_single_sign_on_list_request(
870 resource_group_name: str, monitor_name: str, subscription_id: str, **kwargs: Any
871) -> HttpRequest:
872 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
873 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
875 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
876 accept = _headers.pop("Accept", "application/json")
878 # Construct URL
879 _url = "/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Dynatrace.Observability/monitors/{monitorName}/singleSignOnConfigurations"
880 path_format_arguments = {
881 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
882 "resourceGroupName": _SERIALIZER.url("resource_group_name", resource_group_name, "str"),
883 "monitorName": _SERIALIZER.url("monitor_name", monitor_name, "str"),
884 }
886 _url: str = _url.format(**path_format_arguments) # type: ignore
888 # Construct parameters
889 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
891 # Construct headers
892 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
894 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
897def build_creation_supported_list_request(
898 dynatrace_environment_id: str, subscription_id: str, **kwargs: Any
899) -> HttpRequest:
900 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
901 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
903 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
904 accept = _headers.pop("Accept", "application/json")
906 # Construct URL
907 _url = "/subscriptions/{subscriptionId}/providers/Dynatrace.Observability/subscriptionStatuses/{dynatraceEnvironmentId}"
908 path_format_arguments = {
909 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
910 "dynatraceEnvironmentId": _SERIALIZER.url("dynatrace_environment_id", dynatrace_environment_id, "str"),
911 }
913 _url: str = _url.format(**path_format_arguments) # type: ignore
915 # Construct parameters
916 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
918 # Construct headers
919 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
921 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
924def build_creation_supported_get_request(
925 dynatrace_environment_id: str, subscription_id: str, **kwargs: Any
926) -> HttpRequest:
927 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
928 _params = case_insensitive_dict(kwargs.pop("params", {}) or {})
930 api_version: str = kwargs.pop("api_version", _params.pop("api-version", "2024-04-24"))
931 accept = _headers.pop("Accept", "application/json")
933 # Construct URL
934 _url = "/subscriptions/{subscriptionId}/providers/Dynatrace.Observability/subscriptionStatuses/{dynatraceEnvironmentId}/default"
935 path_format_arguments = {
936 "subscriptionId": _SERIALIZER.url("subscription_id", subscription_id, "str"),
937 "dynatraceEnvironmentId": _SERIALIZER.url("dynatrace_environment_id", dynatrace_environment_id, "str"),
938 }
940 _url: str = _url.format(**path_format_arguments) # type: ignore
942 # Construct parameters
943 _params["api-version"] = _SERIALIZER.query("api_version", api_version, "str")
945 # Construct headers
946 _headers["Accept"] = _SERIALIZER.header("accept", accept, "str")
948 return HttpRequest(method="GET", url=_url, params=_params, headers=_headers, **kwargs)
951class Operations:
952 """
953 .. warning::
954 **DO NOT** instantiate this class directly.
956 Instead, you should access the following operations through
957 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
958 :attr:`operations` attribute.
959 """
961 def __init__(self, *args, **kwargs) -> None:
962 input_args = list(args)
963 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
964 self._config: DynatraceObservabilityMgmtClientConfiguration = (
965 input_args.pop(0) if input_args else kwargs.pop("config")
966 )
967 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
968 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
970 @distributed_trace
971 def list(self, **kwargs: Any) -> ItemPaged["_models.Operation"]:
972 """List the operations for the provider.
974 :return: An iterator like instance of Operation
975 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.Operation]
976 :raises ~azure.core.exceptions.HttpResponseError:
977 """
978 _headers = kwargs.pop("headers", {}) or {}
979 _params = kwargs.pop("params", {}) or {}
981 cls: ClsType[List[_models.Operation]] = kwargs.pop("cls", None)
983 error_map: MutableMapping = {
984 401: ClientAuthenticationError,
985 404: ResourceNotFoundError,
986 409: ResourceExistsError,
987 304: ResourceNotModifiedError,
988 }
989 error_map.update(kwargs.pop("error_map", {}) or {})
991 def prepare_request(next_link=None):
992 if not next_link:
994 _request = build_operations_list_request(
995 api_version=self._config.api_version,
996 headers=_headers,
997 params=_params,
998 )
999 path_format_arguments = {
1000 "endpoint": self._serialize.url(
1001 "self._config.base_url", self._config.base_url, "str", skip_quote=True
1002 ),
1003 }
1004 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1006 else:
1007 # make call to next link with the client's api-version
1008 _parsed_next_link = urllib.parse.urlparse(next_link)
1009 _next_request_params = case_insensitive_dict(
1010 {
1011 key: [urllib.parse.quote(v) for v in value]
1012 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
1013 }
1014 )
1015 _next_request_params["api-version"] = self._config.api_version
1016 _request = HttpRequest(
1017 "GET",
1018 urllib.parse.urljoin(next_link, _parsed_next_link.path),
1019 headers=_headers,
1020 params=_next_request_params,
1021 )
1022 path_format_arguments = {
1023 "endpoint": self._serialize.url(
1024 "self._config.base_url", self._config.base_url, "str", skip_quote=True
1025 ),
1026 }
1027 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1029 return _request
1031 def extract_data(pipeline_response):
1032 deserialized = pipeline_response.http_response.json()
1033 list_of_elem = _deserialize(
1034 List[_models.Operation],
1035 deserialized.get("value", []),
1036 )
1037 if cls:
1038 list_of_elem = cls(list_of_elem) # type: ignore
1039 return deserialized.get("nextLink") or None, iter(list_of_elem)
1041 def get_next(next_link=None):
1042 _request = prepare_request(next_link)
1044 _stream = False
1045 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1046 _request, stream=_stream, **kwargs
1047 )
1048 response = pipeline_response.http_response
1050 if response.status_code not in [200]:
1051 map_error(status_code=response.status_code, response=response, error_map=error_map)
1052 error = _failsafe_deserialize(
1053 _models.ErrorResponse,
1054 response,
1055 )
1056 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1058 return pipeline_response
1060 return ItemPaged(get_next, extract_data)
1063class MonitoredSubscriptionsOperations:
1064 """
1065 .. warning::
1066 **DO NOT** instantiate this class directly.
1068 Instead, you should access the following operations through
1069 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
1070 :attr:`monitored_subscriptions` attribute.
1071 """
1073 def __init__(self, *args, **kwargs) -> None:
1074 input_args = list(args)
1075 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
1076 self._config: DynatraceObservabilityMgmtClientConfiguration = (
1077 input_args.pop(0) if input_args else kwargs.pop("config")
1078 )
1079 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
1080 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
1082 @distributed_trace
1083 def get(
1084 self, resource_group_name: str, monitor_name: str, **kwargs: Any
1085 ) -> _models.MonitoredSubscriptionProperties:
1086 """List the subscriptions currently being monitored by the Dynatrace monitor resource.
1088 :param resource_group_name: The name of the resource group. The name is case insensitive.
1089 Required.
1090 :type resource_group_name: str
1091 :param monitor_name: Monitor resource name. Required.
1092 :type monitor_name: str
1093 :return: MonitoredSubscriptionProperties. The MonitoredSubscriptionProperties is compatible
1094 with MutableMapping
1095 :rtype: ~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties
1096 :raises ~azure.core.exceptions.HttpResponseError:
1097 """
1098 error_map: MutableMapping = {
1099 401: ClientAuthenticationError,
1100 404: ResourceNotFoundError,
1101 409: ResourceExistsError,
1102 304: ResourceNotModifiedError,
1103 }
1104 error_map.update(kwargs.pop("error_map", {}) or {})
1106 _headers = kwargs.pop("headers", {}) or {}
1107 _params = kwargs.pop("params", {}) or {}
1109 cls: ClsType[_models.MonitoredSubscriptionProperties] = kwargs.pop("cls", None)
1111 _request = build_monitored_subscriptions_get_request(
1112 resource_group_name=resource_group_name,
1113 monitor_name=monitor_name,
1114 subscription_id=self._config.subscription_id,
1115 api_version=self._config.api_version,
1116 headers=_headers,
1117 params=_params,
1118 )
1119 path_format_arguments = {
1120 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1121 }
1122 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1124 _decompress = kwargs.pop("decompress", True)
1125 _stream = kwargs.pop("stream", False)
1126 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1127 _request, stream=_stream, **kwargs
1128 )
1130 response = pipeline_response.http_response
1132 if response.status_code not in [200]:
1133 if _stream:
1134 try:
1135 response.read() # Load the body in memory and close the socket
1136 except (StreamConsumedError, StreamClosedError):
1137 pass
1138 map_error(status_code=response.status_code, response=response, error_map=error_map)
1139 error = _failsafe_deserialize(
1140 _models.ErrorResponse,
1141 response,
1142 )
1143 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1145 if _stream:
1146 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
1147 else:
1148 deserialized = _deserialize(_models.MonitoredSubscriptionProperties, response.json())
1150 if cls:
1151 return cls(pipeline_response, deserialized, {}) # type: ignore
1153 return deserialized # type: ignore
1155 def _create_or_update_initial(
1156 self,
1157 resource_group_name: str,
1158 monitor_name: str,
1159 body: Optional[
1160 Union[_models.MonitoredSubscriptionProperties, _types.MonitoredSubscriptionProperties, IO[bytes]]
1161 ] = None,
1162 **kwargs: Any
1163 ) -> Iterator[bytes]:
1164 error_map: MutableMapping = {
1165 401: ClientAuthenticationError,
1166 404: ResourceNotFoundError,
1167 409: ResourceExistsError,
1168 304: ResourceNotModifiedError,
1169 }
1170 error_map.update(kwargs.pop("error_map", {}) or {})
1172 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
1173 _params = kwargs.pop("params", {}) or {}
1175 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
1176 content_type = content_type if body else None
1177 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
1179 content_type = content_type or "application/json" if body else None
1180 _content = None
1181 if isinstance(body, (IOBase, bytes)):
1182 _content = body
1183 else:
1184 if body is not None:
1185 _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
1186 else:
1187 _content = None
1189 _request = build_monitored_subscriptions_create_or_update_request(
1190 resource_group_name=resource_group_name,
1191 monitor_name=monitor_name,
1192 subscription_id=self._config.subscription_id,
1193 content_type=content_type,
1194 api_version=self._config.api_version,
1195 content=_content,
1196 headers=_headers,
1197 params=_params,
1198 )
1199 path_format_arguments = {
1200 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1201 }
1202 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1204 _decompress = kwargs.pop("decompress", True)
1205 _stream = True
1206 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1207 _request, stream=_stream, **kwargs
1208 )
1210 response = pipeline_response.http_response
1212 if response.status_code not in [200, 201]:
1213 try:
1214 response.read() # Load the body in memory and close the socket
1215 except (StreamConsumedError, StreamClosedError):
1216 pass
1217 map_error(status_code=response.status_code, response=response, error_map=error_map)
1218 error = _failsafe_deserialize(
1219 _models.ErrorResponse,
1220 response,
1221 )
1222 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1224 response_headers = {}
1225 if response.status_code == 201:
1226 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
1227 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
1229 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
1231 if cls:
1232 return cls(pipeline_response, deserialized, response_headers) # type: ignore
1234 return deserialized # type: ignore
1236 @overload
1237 def begin_create_or_update(
1238 self,
1239 resource_group_name: str,
1240 monitor_name: str,
1241 body: Optional[_models.MonitoredSubscriptionProperties] = None,
1242 *,
1243 content_type: str = "application/json",
1244 **kwargs: Any
1245 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1246 """Add the subscriptions that should be monitored by the Dynatrace monitor resource.
1248 :param resource_group_name: The name of the resource group. The name is case insensitive.
1249 Required.
1250 :type resource_group_name: str
1251 :param monitor_name: Monitor resource name. Required.
1252 :type monitor_name: str
1253 :param body: Default value is None.
1254 :type body: ~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties
1255 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
1256 Default value is "application/json".
1257 :paramtype content_type: str
1258 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1259 MonitoredSubscriptionProperties is compatible with MutableMapping
1260 :rtype:
1261 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1262 :raises ~azure.core.exceptions.HttpResponseError:
1263 """
1265 @overload
1266 def begin_create_or_update(
1267 self,
1268 resource_group_name: str,
1269 monitor_name: str,
1270 body: Optional[_types.MonitoredSubscriptionProperties] = None,
1271 *,
1272 content_type: str = "application/json",
1273 **kwargs: Any
1274 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1275 """Add the subscriptions that should be monitored by the Dynatrace monitor resource.
1277 :param resource_group_name: The name of the resource group. The name is case insensitive.
1278 Required.
1279 :type resource_group_name: str
1280 :param monitor_name: Monitor resource name. Required.
1281 :type monitor_name: str
1282 :param body: Default value is None.
1283 :type body: ~azure.mgmt.dynatrace.types.MonitoredSubscriptionProperties
1284 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
1285 Default value is "application/json".
1286 :paramtype content_type: str
1287 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1288 MonitoredSubscriptionProperties is compatible with MutableMapping
1289 :rtype:
1290 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1291 :raises ~azure.core.exceptions.HttpResponseError:
1292 """
1294 @overload
1295 def begin_create_or_update(
1296 self,
1297 resource_group_name: str,
1298 monitor_name: str,
1299 body: Optional[IO[bytes]] = None,
1300 *,
1301 content_type: str = "application/json",
1302 **kwargs: Any
1303 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1304 """Add the subscriptions that should be monitored by the Dynatrace monitor resource.
1306 :param resource_group_name: The name of the resource group. The name is case insensitive.
1307 Required.
1308 :type resource_group_name: str
1309 :param monitor_name: Monitor resource name. Required.
1310 :type monitor_name: str
1311 :param body: Default value is None.
1312 :type body: IO[bytes]
1313 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
1314 Default value is "application/json".
1315 :paramtype content_type: str
1316 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1317 MonitoredSubscriptionProperties is compatible with MutableMapping
1318 :rtype:
1319 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1320 :raises ~azure.core.exceptions.HttpResponseError:
1321 """
1323 @distributed_trace
1324 def begin_create_or_update(
1325 self,
1326 resource_group_name: str,
1327 monitor_name: str,
1328 body: Optional[
1329 Union[_models.MonitoredSubscriptionProperties, _types.MonitoredSubscriptionProperties, IO[bytes]]
1330 ] = None,
1331 **kwargs: Any
1332 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1333 """Add the subscriptions that should be monitored by the Dynatrace monitor resource.
1335 :param resource_group_name: The name of the resource group. The name is case insensitive.
1336 Required.
1337 :type resource_group_name: str
1338 :param monitor_name: Monitor resource name. Required.
1339 :type monitor_name: str
1340 :param body: Is either a MonitoredSubscriptionProperties type or a IO[bytes] type. Default
1341 value is None.
1342 :type body: ~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties or
1343 ~azure.mgmt.dynatrace.types.MonitoredSubscriptionProperties or IO[bytes]
1344 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1345 MonitoredSubscriptionProperties is compatible with MutableMapping
1346 :rtype:
1347 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1348 :raises ~azure.core.exceptions.HttpResponseError:
1349 """
1350 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
1351 _params = kwargs.pop("params", {}) or {}
1353 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
1354 content_type = content_type if body else None
1355 cls: ClsType[_models.MonitoredSubscriptionProperties] = kwargs.pop("cls", None)
1356 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
1357 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
1358 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
1359 if cont_token is None:
1360 raw_result = self._create_or_update_initial(
1361 resource_group_name=resource_group_name,
1362 monitor_name=monitor_name,
1363 body=body,
1364 content_type=content_type,
1365 cls=lambda x, y, z: x,
1366 headers=_headers,
1367 params=_params,
1368 **kwargs
1369 )
1370 raw_result.http_response.read() # type: ignore
1371 kwargs.pop("error_map", None)
1373 def get_long_running_output(pipeline_response):
1374 response = pipeline_response.http_response
1375 deserialized = _deserialize(_models.MonitoredSubscriptionProperties, response.json())
1376 if cls:
1377 return cls(pipeline_response, deserialized, {}) # type: ignore
1378 return deserialized
1380 path_format_arguments = {
1381 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1382 }
1384 if polling is True:
1385 polling_method: PollingMethod = cast(
1386 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
1387 )
1388 elif polling is False:
1389 polling_method = cast(PollingMethod, NoPolling())
1390 else:
1391 polling_method = polling
1392 if cont_token:
1393 return LROPoller[_models.MonitoredSubscriptionProperties].from_continuation_token(
1394 polling_method=polling_method,
1395 continuation_token=cont_token,
1396 client=self._client,
1397 deserialization_callback=get_long_running_output,
1398 )
1399 return LROPoller[_models.MonitoredSubscriptionProperties](
1400 self._client, raw_result, get_long_running_output, polling_method # type: ignore
1401 )
1403 def _update_initial(
1404 self,
1405 resource_group_name: str,
1406 monitor_name: str,
1407 body: Optional[
1408 Union[_models.MonitoredSubscriptionProperties, _types.MonitoredSubscriptionProperties, IO[bytes]]
1409 ] = None,
1410 **kwargs: Any
1411 ) -> Iterator[bytes]:
1412 error_map: MutableMapping = {
1413 401: ClientAuthenticationError,
1414 404: ResourceNotFoundError,
1415 409: ResourceExistsError,
1416 304: ResourceNotModifiedError,
1417 }
1418 error_map.update(kwargs.pop("error_map", {}) or {})
1420 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
1421 _params = kwargs.pop("params", {}) or {}
1423 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
1424 content_type = content_type if body else None
1425 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
1427 content_type = content_type or "application/json" if body else None
1428 _content = None
1429 if isinstance(body, (IOBase, bytes)):
1430 _content = body
1431 else:
1432 if body is not None:
1433 _content = json.dumps(body, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
1434 else:
1435 _content = None
1437 _request = build_monitored_subscriptions_update_request(
1438 resource_group_name=resource_group_name,
1439 monitor_name=monitor_name,
1440 subscription_id=self._config.subscription_id,
1441 content_type=content_type,
1442 api_version=self._config.api_version,
1443 content=_content,
1444 headers=_headers,
1445 params=_params,
1446 )
1447 path_format_arguments = {
1448 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1449 }
1450 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1452 _decompress = kwargs.pop("decompress", True)
1453 _stream = True
1454 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1455 _request, stream=_stream, **kwargs
1456 )
1458 response = pipeline_response.http_response
1460 if response.status_code not in [200, 202]:
1461 try:
1462 response.read() # Load the body in memory and close the socket
1463 except (StreamConsumedError, StreamClosedError):
1464 pass
1465 map_error(status_code=response.status_code, response=response, error_map=error_map)
1466 error = _failsafe_deserialize(
1467 _models.ErrorResponse,
1468 response,
1469 )
1470 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1472 response_headers = {}
1473 if response.status_code == 202:
1474 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
1475 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
1477 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
1479 if cls:
1480 return cls(pipeline_response, deserialized, response_headers) # type: ignore
1482 return deserialized # type: ignore
1484 @overload
1485 def begin_update(
1486 self,
1487 resource_group_name: str,
1488 monitor_name: str,
1489 body: Optional[_models.MonitoredSubscriptionProperties] = None,
1490 *,
1491 content_type: str = "application/json",
1492 **kwargs: Any
1493 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1494 """Updates the subscriptions that are being monitored by the Dynatrace monitor resource.
1496 :param resource_group_name: The name of the resource group. The name is case insensitive.
1497 Required.
1498 :type resource_group_name: str
1499 :param monitor_name: Monitor resource name. Required.
1500 :type monitor_name: str
1501 :param body: Default value is None.
1502 :type body: ~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties
1503 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
1504 Default value is "application/json".
1505 :paramtype content_type: str
1506 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1507 MonitoredSubscriptionProperties is compatible with MutableMapping
1508 :rtype:
1509 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1510 :raises ~azure.core.exceptions.HttpResponseError:
1511 """
1513 @overload
1514 def begin_update(
1515 self,
1516 resource_group_name: str,
1517 monitor_name: str,
1518 body: Optional[_types.MonitoredSubscriptionProperties] = None,
1519 *,
1520 content_type: str = "application/json",
1521 **kwargs: Any
1522 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1523 """Updates the subscriptions that are being monitored by the Dynatrace monitor resource.
1525 :param resource_group_name: The name of the resource group. The name is case insensitive.
1526 Required.
1527 :type resource_group_name: str
1528 :param monitor_name: Monitor resource name. Required.
1529 :type monitor_name: str
1530 :param body: Default value is None.
1531 :type body: ~azure.mgmt.dynatrace.types.MonitoredSubscriptionProperties
1532 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
1533 Default value is "application/json".
1534 :paramtype content_type: str
1535 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1536 MonitoredSubscriptionProperties is compatible with MutableMapping
1537 :rtype:
1538 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1539 :raises ~azure.core.exceptions.HttpResponseError:
1540 """
1542 @overload
1543 def begin_update(
1544 self,
1545 resource_group_name: str,
1546 monitor_name: str,
1547 body: Optional[IO[bytes]] = None,
1548 *,
1549 content_type: str = "application/json",
1550 **kwargs: Any
1551 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1552 """Updates the subscriptions that are being monitored by the Dynatrace monitor resource.
1554 :param resource_group_name: The name of the resource group. The name is case insensitive.
1555 Required.
1556 :type resource_group_name: str
1557 :param monitor_name: Monitor resource name. Required.
1558 :type monitor_name: str
1559 :param body: Default value is None.
1560 :type body: IO[bytes]
1561 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
1562 Default value is "application/json".
1563 :paramtype content_type: str
1564 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1565 MonitoredSubscriptionProperties is compatible with MutableMapping
1566 :rtype:
1567 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1568 :raises ~azure.core.exceptions.HttpResponseError:
1569 """
1571 @distributed_trace
1572 def begin_update(
1573 self,
1574 resource_group_name: str,
1575 monitor_name: str,
1576 body: Optional[
1577 Union[_models.MonitoredSubscriptionProperties, _types.MonitoredSubscriptionProperties, IO[bytes]]
1578 ] = None,
1579 **kwargs: Any
1580 ) -> LROPoller[_models.MonitoredSubscriptionProperties]:
1581 """Updates the subscriptions that are being monitored by the Dynatrace monitor resource.
1583 :param resource_group_name: The name of the resource group. The name is case insensitive.
1584 Required.
1585 :type resource_group_name: str
1586 :param monitor_name: Monitor resource name. Required.
1587 :type monitor_name: str
1588 :param body: Is either a MonitoredSubscriptionProperties type or a IO[bytes] type. Default
1589 value is None.
1590 :type body: ~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties or
1591 ~azure.mgmt.dynatrace.types.MonitoredSubscriptionProperties or IO[bytes]
1592 :return: An instance of LROPoller that returns MonitoredSubscriptionProperties. The
1593 MonitoredSubscriptionProperties is compatible with MutableMapping
1594 :rtype:
1595 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1596 :raises ~azure.core.exceptions.HttpResponseError:
1597 """
1598 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
1599 _params = kwargs.pop("params", {}) or {}
1601 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
1602 content_type = content_type if body else None
1603 cls: ClsType[_models.MonitoredSubscriptionProperties] = kwargs.pop("cls", None)
1604 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
1605 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
1606 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
1607 if cont_token is None:
1608 raw_result = self._update_initial(
1609 resource_group_name=resource_group_name,
1610 monitor_name=monitor_name,
1611 body=body,
1612 content_type=content_type,
1613 cls=lambda x, y, z: x,
1614 headers=_headers,
1615 params=_params,
1616 **kwargs
1617 )
1618 raw_result.http_response.read() # type: ignore
1619 kwargs.pop("error_map", None)
1621 def get_long_running_output(pipeline_response):
1622 response = pipeline_response.http_response
1623 deserialized = _deserialize(_models.MonitoredSubscriptionProperties, response.json())
1624 if cls:
1625 return cls(pipeline_response, deserialized, {}) # type: ignore
1626 return deserialized
1628 path_format_arguments = {
1629 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1630 }
1632 if polling is True:
1633 polling_method: PollingMethod = cast(
1634 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
1635 )
1636 elif polling is False:
1637 polling_method = cast(PollingMethod, NoPolling())
1638 else:
1639 polling_method = polling
1640 if cont_token:
1641 return LROPoller[_models.MonitoredSubscriptionProperties].from_continuation_token(
1642 polling_method=polling_method,
1643 continuation_token=cont_token,
1644 client=self._client,
1645 deserialization_callback=get_long_running_output,
1646 )
1647 return LROPoller[_models.MonitoredSubscriptionProperties](
1648 self._client, raw_result, get_long_running_output, polling_method # type: ignore
1649 )
1651 def _delete_initial(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> Iterator[bytes]:
1652 error_map: MutableMapping = {
1653 401: ClientAuthenticationError,
1654 404: ResourceNotFoundError,
1655 409: ResourceExistsError,
1656 304: ResourceNotModifiedError,
1657 }
1658 error_map.update(kwargs.pop("error_map", {}) or {})
1660 _headers = kwargs.pop("headers", {}) or {}
1661 _params = kwargs.pop("params", {}) or {}
1663 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
1665 _request = build_monitored_subscriptions_delete_request(
1666 resource_group_name=resource_group_name,
1667 monitor_name=monitor_name,
1668 subscription_id=self._config.subscription_id,
1669 api_version=self._config.api_version,
1670 headers=_headers,
1671 params=_params,
1672 )
1673 path_format_arguments = {
1674 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1675 }
1676 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1678 _decompress = kwargs.pop("decompress", True)
1679 _stream = True
1680 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1681 _request, stream=_stream, **kwargs
1682 )
1684 response = pipeline_response.http_response
1686 if response.status_code not in [202, 204]:
1687 try:
1688 response.read() # Load the body in memory and close the socket
1689 except (StreamConsumedError, StreamClosedError):
1690 pass
1691 map_error(status_code=response.status_code, response=response, error_map=error_map)
1692 error = _failsafe_deserialize(
1693 _models.ErrorResponse,
1694 response,
1695 )
1696 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1698 response_headers = {}
1699 if response.status_code == 202:
1700 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
1701 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
1703 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
1705 if cls:
1706 return cls(pipeline_response, deserialized, response_headers) # type: ignore
1708 return deserialized # type: ignore
1710 @distributed_trace
1711 def begin_delete(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> LROPoller[None]:
1712 """Updates the subscriptions that are being monitored by the Dynatrace monitor resource.
1714 :param resource_group_name: The name of the resource group. The name is case insensitive.
1715 Required.
1716 :type resource_group_name: str
1717 :param monitor_name: Monitor resource name. Required.
1718 :type monitor_name: str
1719 :return: An instance of LROPoller that returns None
1720 :rtype: ~azure.core.polling.LROPoller[None]
1721 :raises ~azure.core.exceptions.HttpResponseError:
1722 """
1723 _headers = kwargs.pop("headers", {}) or {}
1724 _params = kwargs.pop("params", {}) or {}
1726 cls: ClsType[None] = kwargs.pop("cls", None)
1727 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
1728 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
1729 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
1730 if cont_token is None:
1731 raw_result = self._delete_initial(
1732 resource_group_name=resource_group_name,
1733 monitor_name=monitor_name,
1734 cls=lambda x, y, z: x,
1735 headers=_headers,
1736 params=_params,
1737 **kwargs
1738 )
1739 raw_result.http_response.read() # type: ignore
1740 kwargs.pop("error_map", None)
1742 def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements
1743 if cls:
1744 return cls(pipeline_response, None, {}) # type: ignore
1746 path_format_arguments = {
1747 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1748 }
1750 if polling is True:
1751 polling_method: PollingMethod = cast(
1752 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
1753 )
1754 elif polling is False:
1755 polling_method = cast(PollingMethod, NoPolling())
1756 else:
1757 polling_method = polling
1758 if cont_token:
1759 return LROPoller[None].from_continuation_token(
1760 polling_method=polling_method,
1761 continuation_token=cont_token,
1762 client=self._client,
1763 deserialization_callback=get_long_running_output,
1764 )
1765 return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
1767 @distributed_trace
1768 def list(
1769 self, resource_group_name: str, monitor_name: str, **kwargs: Any
1770 ) -> ItemPaged["_models.MonitoredSubscriptionProperties"]:
1771 """List the subscriptions currently being monitored by the Dynatrace monitor resource.
1773 :param resource_group_name: The name of the resource group. The name is case insensitive.
1774 Required.
1775 :type resource_group_name: str
1776 :param monitor_name: Monitor resource name. Required.
1777 :type monitor_name: str
1778 :return: An iterator like instance of MonitoredSubscriptionProperties
1779 :rtype:
1780 ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitoredSubscriptionProperties]
1781 :raises ~azure.core.exceptions.HttpResponseError:
1782 """
1783 _headers = kwargs.pop("headers", {}) or {}
1784 _params = kwargs.pop("params", {}) or {}
1786 cls: ClsType[List[_models.MonitoredSubscriptionProperties]] = kwargs.pop("cls", None)
1788 error_map: MutableMapping = {
1789 401: ClientAuthenticationError,
1790 404: ResourceNotFoundError,
1791 409: ResourceExistsError,
1792 304: ResourceNotModifiedError,
1793 }
1794 error_map.update(kwargs.pop("error_map", {}) or {})
1796 def prepare_request(next_link=None):
1797 if not next_link:
1799 _request = build_monitored_subscriptions_list_request(
1800 resource_group_name=resource_group_name,
1801 monitor_name=monitor_name,
1802 subscription_id=self._config.subscription_id,
1803 api_version=self._config.api_version,
1804 headers=_headers,
1805 params=_params,
1806 )
1807 path_format_arguments = {
1808 "endpoint": self._serialize.url(
1809 "self._config.base_url", self._config.base_url, "str", skip_quote=True
1810 ),
1811 }
1812 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1814 else:
1815 # make call to next link with the client's api-version
1816 _parsed_next_link = urllib.parse.urlparse(next_link)
1817 _next_request_params = case_insensitive_dict(
1818 {
1819 key: [urllib.parse.quote(v) for v in value]
1820 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
1821 }
1822 )
1823 _next_request_params["api-version"] = self._config.api_version
1824 _request = HttpRequest(
1825 "GET",
1826 urllib.parse.urljoin(next_link, _parsed_next_link.path),
1827 headers=_headers,
1828 params=_next_request_params,
1829 )
1830 path_format_arguments = {
1831 "endpoint": self._serialize.url(
1832 "self._config.base_url", self._config.base_url, "str", skip_quote=True
1833 ),
1834 }
1835 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1837 return _request
1839 def extract_data(pipeline_response):
1840 deserialized = pipeline_response.http_response.json()
1841 list_of_elem = _deserialize(
1842 List[_models.MonitoredSubscriptionProperties],
1843 deserialized.get("value", []),
1844 )
1845 if cls:
1846 list_of_elem = cls(list_of_elem) # type: ignore
1847 return deserialized.get("nextLink") or None, iter(list_of_elem)
1849 def get_next(next_link=None):
1850 _request = prepare_request(next_link)
1852 _stream = False
1853 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1854 _request, stream=_stream, **kwargs
1855 )
1856 response = pipeline_response.http_response
1858 if response.status_code not in [200]:
1859 map_error(status_code=response.status_code, response=response, error_map=error_map)
1860 error = _failsafe_deserialize(
1861 _models.ErrorResponse,
1862 response,
1863 )
1864 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1866 return pipeline_response
1868 return ItemPaged(get_next, extract_data)
1871class TagRulesOperations:
1872 """
1873 .. warning::
1874 **DO NOT** instantiate this class directly.
1876 Instead, you should access the following operations through
1877 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
1878 :attr:`tag_rules` attribute.
1879 """
1881 def __init__(self, *args, **kwargs) -> None:
1882 input_args = list(args)
1883 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
1884 self._config: DynatraceObservabilityMgmtClientConfiguration = (
1885 input_args.pop(0) if input_args else kwargs.pop("config")
1886 )
1887 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
1888 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
1890 @distributed_trace
1891 def get(self, resource_group_name: str, monitor_name: str, rule_set_name: str, **kwargs: Any) -> _models.TagRule:
1892 """Get a TagRule.
1894 :param resource_group_name: The name of the resource group. The name is case insensitive.
1895 Required.
1896 :type resource_group_name: str
1897 :param monitor_name: Monitor resource name. Required.
1898 :type monitor_name: str
1899 :param rule_set_name: Monitor resource name. Required.
1900 :type rule_set_name: str
1901 :return: TagRule. The TagRule is compatible with MutableMapping
1902 :rtype: ~azure.mgmt.dynatrace.models.TagRule
1903 :raises ~azure.core.exceptions.HttpResponseError:
1904 """
1905 error_map: MutableMapping = {
1906 401: ClientAuthenticationError,
1907 404: ResourceNotFoundError,
1908 409: ResourceExistsError,
1909 304: ResourceNotModifiedError,
1910 }
1911 error_map.update(kwargs.pop("error_map", {}) or {})
1913 _headers = kwargs.pop("headers", {}) or {}
1914 _params = kwargs.pop("params", {}) or {}
1916 cls: ClsType[_models.TagRule] = kwargs.pop("cls", None)
1918 _request = build_tag_rules_get_request(
1919 resource_group_name=resource_group_name,
1920 monitor_name=monitor_name,
1921 rule_set_name=rule_set_name,
1922 subscription_id=self._config.subscription_id,
1923 api_version=self._config.api_version,
1924 headers=_headers,
1925 params=_params,
1926 )
1927 path_format_arguments = {
1928 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
1929 }
1930 _request.url = self._client.format_url(_request.url, **path_format_arguments)
1932 _decompress = kwargs.pop("decompress", True)
1933 _stream = kwargs.pop("stream", False)
1934 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
1935 _request, stream=_stream, **kwargs
1936 )
1938 response = pipeline_response.http_response
1940 if response.status_code not in [200]:
1941 if _stream:
1942 try:
1943 response.read() # Load the body in memory and close the socket
1944 except (StreamConsumedError, StreamClosedError):
1945 pass
1946 map_error(status_code=response.status_code, response=response, error_map=error_map)
1947 error = _failsafe_deserialize(
1948 _models.ErrorResponse,
1949 response,
1950 )
1951 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
1953 if _stream:
1954 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
1955 else:
1956 deserialized = _deserialize(_models.TagRule, response.json())
1958 if cls:
1959 return cls(pipeline_response, deserialized, {}) # type: ignore
1961 return deserialized # type: ignore
1963 def _create_or_update_initial(
1964 self,
1965 resource_group_name: str,
1966 monitor_name: str,
1967 rule_set_name: str,
1968 resource: Union[_models.TagRule, _types.TagRule, IO[bytes]],
1969 **kwargs: Any
1970 ) -> Iterator[bytes]:
1971 error_map: MutableMapping = {
1972 401: ClientAuthenticationError,
1973 404: ResourceNotFoundError,
1974 409: ResourceExistsError,
1975 304: ResourceNotModifiedError,
1976 }
1977 error_map.update(kwargs.pop("error_map", {}) or {})
1979 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
1980 _params = kwargs.pop("params", {}) or {}
1982 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
1983 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
1985 content_type = content_type or "application/json"
1986 _content = None
1987 if isinstance(resource, (IOBase, bytes)):
1988 _content = resource
1989 else:
1990 _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
1992 _request = build_tag_rules_create_or_update_request(
1993 resource_group_name=resource_group_name,
1994 monitor_name=monitor_name,
1995 rule_set_name=rule_set_name,
1996 subscription_id=self._config.subscription_id,
1997 content_type=content_type,
1998 api_version=self._config.api_version,
1999 content=_content,
2000 headers=_headers,
2001 params=_params,
2002 )
2003 path_format_arguments = {
2004 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2005 }
2006 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2008 _decompress = kwargs.pop("decompress", True)
2009 _stream = True
2010 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2011 _request, stream=_stream, **kwargs
2012 )
2014 response = pipeline_response.http_response
2016 if response.status_code not in [200, 201]:
2017 try:
2018 response.read() # Load the body in memory and close the socket
2019 except (StreamConsumedError, StreamClosedError):
2020 pass
2021 map_error(status_code=response.status_code, response=response, error_map=error_map)
2022 error = _failsafe_deserialize(
2023 _models.ErrorResponse,
2024 response,
2025 )
2026 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2028 response_headers = {}
2029 if response.status_code == 201:
2030 response_headers["Azure-AsyncOperation"] = self._deserialize(
2031 "str", response.headers.get("Azure-AsyncOperation")
2032 )
2033 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
2035 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2037 if cls:
2038 return cls(pipeline_response, deserialized, response_headers) # type: ignore
2040 return deserialized # type: ignore
2042 @overload
2043 def begin_create_or_update(
2044 self,
2045 resource_group_name: str,
2046 monitor_name: str,
2047 rule_set_name: str,
2048 resource: _models.TagRule,
2049 *,
2050 content_type: str = "application/json",
2051 **kwargs: Any
2052 ) -> LROPoller[_models.TagRule]:
2053 """Create a TagRule.
2055 :param resource_group_name: The name of the resource group. The name is case insensitive.
2056 Required.
2057 :type resource_group_name: str
2058 :param monitor_name: Monitor resource name. Required.
2059 :type monitor_name: str
2060 :param rule_set_name: Monitor resource name. Required.
2061 :type rule_set_name: str
2062 :param resource: Resource create parameters. Required.
2063 :type resource: ~azure.mgmt.dynatrace.models.TagRule
2064 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2065 Default value is "application/json".
2066 :paramtype content_type: str
2067 :return: An instance of LROPoller that returns TagRule. The TagRule is compatible with
2068 MutableMapping
2069 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.TagRule]
2070 :raises ~azure.core.exceptions.HttpResponseError:
2071 """
2073 @overload
2074 def begin_create_or_update(
2075 self,
2076 resource_group_name: str,
2077 monitor_name: str,
2078 rule_set_name: str,
2079 resource: _types.TagRule,
2080 *,
2081 content_type: str = "application/json",
2082 **kwargs: Any
2083 ) -> LROPoller[_models.TagRule]:
2084 """Create a TagRule.
2086 :param resource_group_name: The name of the resource group. The name is case insensitive.
2087 Required.
2088 :type resource_group_name: str
2089 :param monitor_name: Monitor resource name. Required.
2090 :type monitor_name: str
2091 :param rule_set_name: Monitor resource name. Required.
2092 :type rule_set_name: str
2093 :param resource: Resource create parameters. Required.
2094 :type resource: ~azure.mgmt.dynatrace.types.TagRule
2095 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2096 Default value is "application/json".
2097 :paramtype content_type: str
2098 :return: An instance of LROPoller that returns TagRule. The TagRule is compatible with
2099 MutableMapping
2100 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.TagRule]
2101 :raises ~azure.core.exceptions.HttpResponseError:
2102 """
2104 @overload
2105 def begin_create_or_update(
2106 self,
2107 resource_group_name: str,
2108 monitor_name: str,
2109 rule_set_name: str,
2110 resource: IO[bytes],
2111 *,
2112 content_type: str = "application/json",
2113 **kwargs: Any
2114 ) -> LROPoller[_models.TagRule]:
2115 """Create a TagRule.
2117 :param resource_group_name: The name of the resource group. The name is case insensitive.
2118 Required.
2119 :type resource_group_name: str
2120 :param monitor_name: Monitor resource name. Required.
2121 :type monitor_name: str
2122 :param rule_set_name: Monitor resource name. Required.
2123 :type rule_set_name: str
2124 :param resource: Resource create parameters. Required.
2125 :type resource: IO[bytes]
2126 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
2127 Default value is "application/json".
2128 :paramtype content_type: str
2129 :return: An instance of LROPoller that returns TagRule. The TagRule is compatible with
2130 MutableMapping
2131 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.TagRule]
2132 :raises ~azure.core.exceptions.HttpResponseError:
2133 """
2135 @distributed_trace
2136 def begin_create_or_update(
2137 self,
2138 resource_group_name: str,
2139 monitor_name: str,
2140 rule_set_name: str,
2141 resource: Union[_models.TagRule, _types.TagRule, IO[bytes]],
2142 **kwargs: Any
2143 ) -> LROPoller[_models.TagRule]:
2144 """Create a TagRule.
2146 :param resource_group_name: The name of the resource group. The name is case insensitive.
2147 Required.
2148 :type resource_group_name: str
2149 :param monitor_name: Monitor resource name. Required.
2150 :type monitor_name: str
2151 :param rule_set_name: Monitor resource name. Required.
2152 :type rule_set_name: str
2153 :param resource: Resource create parameters. Is either a TagRule type or a IO[bytes] type.
2154 Required.
2155 :type resource: ~azure.mgmt.dynatrace.models.TagRule or ~azure.mgmt.dynatrace.types.TagRule or
2156 IO[bytes]
2157 :return: An instance of LROPoller that returns TagRule. The TagRule is compatible with
2158 MutableMapping
2159 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.TagRule]
2160 :raises ~azure.core.exceptions.HttpResponseError:
2161 """
2162 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
2163 _params = kwargs.pop("params", {}) or {}
2165 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
2166 cls: ClsType[_models.TagRule] = kwargs.pop("cls", None)
2167 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
2168 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
2169 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
2170 if cont_token is None:
2171 raw_result = self._create_or_update_initial(
2172 resource_group_name=resource_group_name,
2173 monitor_name=monitor_name,
2174 rule_set_name=rule_set_name,
2175 resource=resource,
2176 content_type=content_type,
2177 cls=lambda x, y, z: x,
2178 headers=_headers,
2179 params=_params,
2180 **kwargs
2181 )
2182 raw_result.http_response.read() # type: ignore
2183 kwargs.pop("error_map", None)
2185 def get_long_running_output(pipeline_response):
2186 response = pipeline_response.http_response
2187 deserialized = _deserialize(_models.TagRule, response.json())
2188 if cls:
2189 return cls(pipeline_response, deserialized, {}) # type: ignore
2190 return deserialized
2192 path_format_arguments = {
2193 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2194 }
2196 if polling is True:
2197 polling_method: PollingMethod = cast(
2198 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
2199 )
2200 elif polling is False:
2201 polling_method = cast(PollingMethod, NoPolling())
2202 else:
2203 polling_method = polling
2204 if cont_token:
2205 return LROPoller[_models.TagRule].from_continuation_token(
2206 polling_method=polling_method,
2207 continuation_token=cont_token,
2208 client=self._client,
2209 deserialization_callback=get_long_running_output,
2210 )
2211 return LROPoller[_models.TagRule](
2212 self._client, raw_result, get_long_running_output, polling_method # type: ignore
2213 )
2215 def _delete_initial(
2216 self, resource_group_name: str, monitor_name: str, rule_set_name: str, **kwargs: Any
2217 ) -> Iterator[bytes]:
2218 error_map: MutableMapping = {
2219 401: ClientAuthenticationError,
2220 404: ResourceNotFoundError,
2221 409: ResourceExistsError,
2222 304: ResourceNotModifiedError,
2223 }
2224 error_map.update(kwargs.pop("error_map", {}) or {})
2226 _headers = kwargs.pop("headers", {}) or {}
2227 _params = kwargs.pop("params", {}) or {}
2229 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
2231 _request = build_tag_rules_delete_request(
2232 resource_group_name=resource_group_name,
2233 monitor_name=monitor_name,
2234 rule_set_name=rule_set_name,
2235 subscription_id=self._config.subscription_id,
2236 api_version=self._config.api_version,
2237 headers=_headers,
2238 params=_params,
2239 )
2240 path_format_arguments = {
2241 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2242 }
2243 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2245 _decompress = kwargs.pop("decompress", True)
2246 _stream = True
2247 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2248 _request, stream=_stream, **kwargs
2249 )
2251 response = pipeline_response.http_response
2253 if response.status_code not in [202, 204]:
2254 try:
2255 response.read() # Load the body in memory and close the socket
2256 except (StreamConsumedError, StreamClosedError):
2257 pass
2258 map_error(status_code=response.status_code, response=response, error_map=error_map)
2259 error = _failsafe_deserialize(
2260 _models.ErrorResponse,
2261 response,
2262 )
2263 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2265 response_headers = {}
2266 if response.status_code == 202:
2267 response_headers["Azure-AsyncOperation"] = self._deserialize(
2268 "str", response.headers.get("Azure-AsyncOperation")
2269 )
2270 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
2271 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
2273 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2275 if cls:
2276 return cls(pipeline_response, deserialized, response_headers) # type: ignore
2278 return deserialized # type: ignore
2280 @distributed_trace
2281 def begin_delete(
2282 self, resource_group_name: str, monitor_name: str, rule_set_name: str, **kwargs: Any
2283 ) -> LROPoller[None]:
2284 """Delete a TagRule.
2286 :param resource_group_name: The name of the resource group. The name is case insensitive.
2287 Required.
2288 :type resource_group_name: str
2289 :param monitor_name: Monitor resource name. Required.
2290 :type monitor_name: str
2291 :param rule_set_name: Monitor resource name. Required.
2292 :type rule_set_name: str
2293 :return: An instance of LROPoller that returns None
2294 :rtype: ~azure.core.polling.LROPoller[None]
2295 :raises ~azure.core.exceptions.HttpResponseError:
2296 """
2297 _headers = kwargs.pop("headers", {}) or {}
2298 _params = kwargs.pop("params", {}) or {}
2300 cls: ClsType[None] = kwargs.pop("cls", None)
2301 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
2302 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
2303 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
2304 if cont_token is None:
2305 raw_result = self._delete_initial(
2306 resource_group_name=resource_group_name,
2307 monitor_name=monitor_name,
2308 rule_set_name=rule_set_name,
2309 cls=lambda x, y, z: x,
2310 headers=_headers,
2311 params=_params,
2312 **kwargs
2313 )
2314 raw_result.http_response.read() # type: ignore
2315 kwargs.pop("error_map", None)
2317 def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements
2318 if cls:
2319 return cls(pipeline_response, None, {}) # type: ignore
2321 path_format_arguments = {
2322 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2323 }
2325 if polling is True:
2326 polling_method: PollingMethod = cast(
2327 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
2328 )
2329 elif polling is False:
2330 polling_method = cast(PollingMethod, NoPolling())
2331 else:
2332 polling_method = polling
2333 if cont_token:
2334 return LROPoller[None].from_continuation_token(
2335 polling_method=polling_method,
2336 continuation_token=cont_token,
2337 client=self._client,
2338 deserialization_callback=get_long_running_output,
2339 )
2340 return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
2342 @distributed_trace
2343 def list(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> ItemPaged["_models.TagRule"]:
2344 """List all TagRule by monitorName.
2346 :param resource_group_name: The name of the resource group. The name is case insensitive.
2347 Required.
2348 :type resource_group_name: str
2349 :param monitor_name: Monitor resource name. Required.
2350 :type monitor_name: str
2351 :return: An iterator like instance of TagRule
2352 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.TagRule]
2353 :raises ~azure.core.exceptions.HttpResponseError:
2354 """
2355 _headers = kwargs.pop("headers", {}) or {}
2356 _params = kwargs.pop("params", {}) or {}
2358 cls: ClsType[List[_models.TagRule]] = kwargs.pop("cls", None)
2360 error_map: MutableMapping = {
2361 401: ClientAuthenticationError,
2362 404: ResourceNotFoundError,
2363 409: ResourceExistsError,
2364 304: ResourceNotModifiedError,
2365 }
2366 error_map.update(kwargs.pop("error_map", {}) or {})
2368 def prepare_request(next_link=None):
2369 if not next_link:
2371 _request = build_tag_rules_list_request(
2372 resource_group_name=resource_group_name,
2373 monitor_name=monitor_name,
2374 subscription_id=self._config.subscription_id,
2375 api_version=self._config.api_version,
2376 headers=_headers,
2377 params=_params,
2378 )
2379 path_format_arguments = {
2380 "endpoint": self._serialize.url(
2381 "self._config.base_url", self._config.base_url, "str", skip_quote=True
2382 ),
2383 }
2384 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2386 else:
2387 # make call to next link with the client's api-version
2388 _parsed_next_link = urllib.parse.urlparse(next_link)
2389 _next_request_params = case_insensitive_dict(
2390 {
2391 key: [urllib.parse.quote(v) for v in value]
2392 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
2393 }
2394 )
2395 _next_request_params["api-version"] = self._config.api_version
2396 _request = HttpRequest(
2397 "GET",
2398 urllib.parse.urljoin(next_link, _parsed_next_link.path),
2399 headers=_headers,
2400 params=_next_request_params,
2401 )
2402 path_format_arguments = {
2403 "endpoint": self._serialize.url(
2404 "self._config.base_url", self._config.base_url, "str", skip_quote=True
2405 ),
2406 }
2407 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2409 return _request
2411 def extract_data(pipeline_response):
2412 deserialized = pipeline_response.http_response.json()
2413 list_of_elem = _deserialize(
2414 List[_models.TagRule],
2415 deserialized.get("value", []),
2416 )
2417 if cls:
2418 list_of_elem = cls(list_of_elem) # type: ignore
2419 return deserialized.get("nextLink") or None, iter(list_of_elem)
2421 def get_next(next_link=None):
2422 _request = prepare_request(next_link)
2424 _stream = False
2425 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2426 _request, stream=_stream, **kwargs
2427 )
2428 response = pipeline_response.http_response
2430 if response.status_code not in [200]:
2431 map_error(status_code=response.status_code, response=response, error_map=error_map)
2432 error = _failsafe_deserialize(
2433 _models.ErrorResponse,
2434 response,
2435 )
2436 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2438 return pipeline_response
2440 return ItemPaged(get_next, extract_data)
2443class MonitorsOperations:
2444 """
2445 .. warning::
2446 **DO NOT** instantiate this class directly.
2448 Instead, you should access the following operations through
2449 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
2450 :attr:`monitors` attribute.
2451 """
2453 def __init__(self, *args, **kwargs) -> None:
2454 input_args = list(args)
2455 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
2456 self._config: DynatraceObservabilityMgmtClientConfiguration = (
2457 input_args.pop(0) if input_args else kwargs.pop("config")
2458 )
2459 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
2460 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
2462 @distributed_trace
2463 def get(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> _models.MonitorResource:
2464 """Get a MonitorResource.
2466 :param resource_group_name: The name of the resource group. The name is case insensitive.
2467 Required.
2468 :type resource_group_name: str
2469 :param monitor_name: Monitor resource name. Required.
2470 :type monitor_name: str
2471 :return: MonitorResource. The MonitorResource is compatible with MutableMapping
2472 :rtype: ~azure.mgmt.dynatrace.models.MonitorResource
2473 :raises ~azure.core.exceptions.HttpResponseError:
2474 """
2475 error_map: MutableMapping = {
2476 401: ClientAuthenticationError,
2477 404: ResourceNotFoundError,
2478 409: ResourceExistsError,
2479 304: ResourceNotModifiedError,
2480 }
2481 error_map.update(kwargs.pop("error_map", {}) or {})
2483 _headers = kwargs.pop("headers", {}) or {}
2484 _params = kwargs.pop("params", {}) or {}
2486 cls: ClsType[_models.MonitorResource] = kwargs.pop("cls", None)
2488 _request = build_monitors_get_request(
2489 resource_group_name=resource_group_name,
2490 monitor_name=monitor_name,
2491 subscription_id=self._config.subscription_id,
2492 api_version=self._config.api_version,
2493 headers=_headers,
2494 params=_params,
2495 )
2496 path_format_arguments = {
2497 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2498 }
2499 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2501 _decompress = kwargs.pop("decompress", True)
2502 _stream = kwargs.pop("stream", False)
2503 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2504 _request, stream=_stream, **kwargs
2505 )
2507 response = pipeline_response.http_response
2509 if response.status_code not in [200]:
2510 if _stream:
2511 try:
2512 response.read() # Load the body in memory and close the socket
2513 except (StreamConsumedError, StreamClosedError):
2514 pass
2515 map_error(status_code=response.status_code, response=response, error_map=error_map)
2516 error = _failsafe_deserialize(
2517 _models.ErrorResponse,
2518 response,
2519 )
2520 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2522 if _stream:
2523 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2524 else:
2525 deserialized = _deserialize(_models.MonitorResource, response.json())
2527 if cls:
2528 return cls(pipeline_response, deserialized, {}) # type: ignore
2530 return deserialized # type: ignore
2532 def _create_or_update_initial(
2533 self,
2534 resource_group_name: str,
2535 monitor_name: str,
2536 resource: Union[_models.MonitorResource, _types.MonitorResource, IO[bytes]],
2537 **kwargs: Any
2538 ) -> Iterator[bytes]:
2539 error_map: MutableMapping = {
2540 401: ClientAuthenticationError,
2541 404: ResourceNotFoundError,
2542 409: ResourceExistsError,
2543 304: ResourceNotModifiedError,
2544 }
2545 error_map.update(kwargs.pop("error_map", {}) or {})
2547 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
2548 _params = kwargs.pop("params", {}) or {}
2550 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
2551 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
2553 content_type = content_type or "application/json"
2554 _content = None
2555 if isinstance(resource, (IOBase, bytes)):
2556 _content = resource
2557 else:
2558 _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
2560 _request = build_monitors_create_or_update_request(
2561 resource_group_name=resource_group_name,
2562 monitor_name=monitor_name,
2563 subscription_id=self._config.subscription_id,
2564 content_type=content_type,
2565 api_version=self._config.api_version,
2566 content=_content,
2567 headers=_headers,
2568 params=_params,
2569 )
2570 path_format_arguments = {
2571 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2572 }
2573 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2575 _decompress = kwargs.pop("decompress", True)
2576 _stream = True
2577 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2578 _request, stream=_stream, **kwargs
2579 )
2581 response = pipeline_response.http_response
2583 if response.status_code not in [200, 201]:
2584 try:
2585 response.read() # Load the body in memory and close the socket
2586 except (StreamConsumedError, StreamClosedError):
2587 pass
2588 map_error(status_code=response.status_code, response=response, error_map=error_map)
2589 error = _failsafe_deserialize(
2590 _models.ErrorResponse,
2591 response,
2592 )
2593 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2595 response_headers = {}
2596 if response.status_code == 201:
2597 response_headers["Azure-AsyncOperation"] = self._deserialize(
2598 "str", response.headers.get("Azure-AsyncOperation")
2599 )
2600 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
2602 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2604 if cls:
2605 return cls(pipeline_response, deserialized, response_headers) # type: ignore
2607 return deserialized # type: ignore
2609 @overload
2610 def begin_create_or_update(
2611 self,
2612 resource_group_name: str,
2613 monitor_name: str,
2614 resource: _models.MonitorResource,
2615 *,
2616 content_type: str = "application/json",
2617 **kwargs: Any
2618 ) -> LROPoller[_models.MonitorResource]:
2619 """Create a MonitorResource.
2621 :param resource_group_name: The name of the resource group. The name is case insensitive.
2622 Required.
2623 :type resource_group_name: str
2624 :param monitor_name: Monitor resource name. Required.
2625 :type monitor_name: str
2626 :param resource: Resource create parameters. Required.
2627 :type resource: ~azure.mgmt.dynatrace.models.MonitorResource
2628 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2629 Default value is "application/json".
2630 :paramtype content_type: str
2631 :return: An instance of LROPoller that returns MonitorResource. The MonitorResource is
2632 compatible with MutableMapping
2633 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitorResource]
2634 :raises ~azure.core.exceptions.HttpResponseError:
2635 """
2637 @overload
2638 def begin_create_or_update(
2639 self,
2640 resource_group_name: str,
2641 monitor_name: str,
2642 resource: _types.MonitorResource,
2643 *,
2644 content_type: str = "application/json",
2645 **kwargs: Any
2646 ) -> LROPoller[_models.MonitorResource]:
2647 """Create a MonitorResource.
2649 :param resource_group_name: The name of the resource group. The name is case insensitive.
2650 Required.
2651 :type resource_group_name: str
2652 :param monitor_name: Monitor resource name. Required.
2653 :type monitor_name: str
2654 :param resource: Resource create parameters. Required.
2655 :type resource: ~azure.mgmt.dynatrace.types.MonitorResource
2656 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2657 Default value is "application/json".
2658 :paramtype content_type: str
2659 :return: An instance of LROPoller that returns MonitorResource. The MonitorResource is
2660 compatible with MutableMapping
2661 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitorResource]
2662 :raises ~azure.core.exceptions.HttpResponseError:
2663 """
2665 @overload
2666 def begin_create_or_update(
2667 self,
2668 resource_group_name: str,
2669 monitor_name: str,
2670 resource: IO[bytes],
2671 *,
2672 content_type: str = "application/json",
2673 **kwargs: Any
2674 ) -> LROPoller[_models.MonitorResource]:
2675 """Create a MonitorResource.
2677 :param resource_group_name: The name of the resource group. The name is case insensitive.
2678 Required.
2679 :type resource_group_name: str
2680 :param monitor_name: Monitor resource name. Required.
2681 :type monitor_name: str
2682 :param resource: Resource create parameters. Required.
2683 :type resource: IO[bytes]
2684 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
2685 Default value is "application/json".
2686 :paramtype content_type: str
2687 :return: An instance of LROPoller that returns MonitorResource. The MonitorResource is
2688 compatible with MutableMapping
2689 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitorResource]
2690 :raises ~azure.core.exceptions.HttpResponseError:
2691 """
2693 @distributed_trace
2694 def begin_create_or_update(
2695 self,
2696 resource_group_name: str,
2697 monitor_name: str,
2698 resource: Union[_models.MonitorResource, _types.MonitorResource, IO[bytes]],
2699 **kwargs: Any
2700 ) -> LROPoller[_models.MonitorResource]:
2701 """Create a MonitorResource.
2703 :param resource_group_name: The name of the resource group. The name is case insensitive.
2704 Required.
2705 :type resource_group_name: str
2706 :param monitor_name: Monitor resource name. Required.
2707 :type monitor_name: str
2708 :param resource: Resource create parameters. Is either a MonitorResource type or a IO[bytes]
2709 type. Required.
2710 :type resource: ~azure.mgmt.dynatrace.models.MonitorResource or
2711 ~azure.mgmt.dynatrace.types.MonitorResource or IO[bytes]
2712 :return: An instance of LROPoller that returns MonitorResource. The MonitorResource is
2713 compatible with MutableMapping
2714 :rtype: ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.MonitorResource]
2715 :raises ~azure.core.exceptions.HttpResponseError:
2716 """
2717 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
2718 _params = kwargs.pop("params", {}) or {}
2720 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
2721 cls: ClsType[_models.MonitorResource] = kwargs.pop("cls", None)
2722 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
2723 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
2724 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
2725 if cont_token is None:
2726 raw_result = self._create_or_update_initial(
2727 resource_group_name=resource_group_name,
2728 monitor_name=monitor_name,
2729 resource=resource,
2730 content_type=content_type,
2731 cls=lambda x, y, z: x,
2732 headers=_headers,
2733 params=_params,
2734 **kwargs
2735 )
2736 raw_result.http_response.read() # type: ignore
2737 kwargs.pop("error_map", None)
2739 def get_long_running_output(pipeline_response):
2740 response = pipeline_response.http_response
2741 deserialized = _deserialize(_models.MonitorResource, response.json())
2742 if cls:
2743 return cls(pipeline_response, deserialized, {}) # type: ignore
2744 return deserialized
2746 path_format_arguments = {
2747 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2748 }
2750 if polling is True:
2751 polling_method: PollingMethod = cast(
2752 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
2753 )
2754 elif polling is False:
2755 polling_method = cast(PollingMethod, NoPolling())
2756 else:
2757 polling_method = polling
2758 if cont_token:
2759 return LROPoller[_models.MonitorResource].from_continuation_token(
2760 polling_method=polling_method,
2761 continuation_token=cont_token,
2762 client=self._client,
2763 deserialization_callback=get_long_running_output,
2764 )
2765 return LROPoller[_models.MonitorResource](
2766 self._client, raw_result, get_long_running_output, polling_method # type: ignore
2767 )
2769 @overload
2770 def update(
2771 self,
2772 resource_group_name: str,
2773 monitor_name: str,
2774 resource: _models.MonitorResourceUpdate,
2775 *,
2776 content_type: str = "application/json",
2777 **kwargs: Any
2778 ) -> _models.MonitorResource:
2779 """Update a MonitorResource.
2781 :param resource_group_name: The name of the resource group. The name is case insensitive.
2782 Required.
2783 :type resource_group_name: str
2784 :param monitor_name: Monitor resource name. Required.
2785 :type monitor_name: str
2786 :param resource: The resource properties to be updated. Required.
2787 :type resource: ~azure.mgmt.dynatrace.models.MonitorResourceUpdate
2788 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2789 Default value is "application/json".
2790 :paramtype content_type: str
2791 :return: MonitorResource. The MonitorResource is compatible with MutableMapping
2792 :rtype: ~azure.mgmt.dynatrace.models.MonitorResource
2793 :raises ~azure.core.exceptions.HttpResponseError:
2794 """
2796 @overload
2797 def update(
2798 self,
2799 resource_group_name: str,
2800 monitor_name: str,
2801 resource: _types.MonitorResourceUpdate,
2802 *,
2803 content_type: str = "application/json",
2804 **kwargs: Any
2805 ) -> _models.MonitorResource:
2806 """Update a MonitorResource.
2808 :param resource_group_name: The name of the resource group. The name is case insensitive.
2809 Required.
2810 :type resource_group_name: str
2811 :param monitor_name: Monitor resource name. Required.
2812 :type monitor_name: str
2813 :param resource: The resource properties to be updated. Required.
2814 :type resource: ~azure.mgmt.dynatrace.types.MonitorResourceUpdate
2815 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
2816 Default value is "application/json".
2817 :paramtype content_type: str
2818 :return: MonitorResource. The MonitorResource is compatible with MutableMapping
2819 :rtype: ~azure.mgmt.dynatrace.models.MonitorResource
2820 :raises ~azure.core.exceptions.HttpResponseError:
2821 """
2823 @overload
2824 def update(
2825 self,
2826 resource_group_name: str,
2827 monitor_name: str,
2828 resource: IO[bytes],
2829 *,
2830 content_type: str = "application/json",
2831 **kwargs: Any
2832 ) -> _models.MonitorResource:
2833 """Update a MonitorResource.
2835 :param resource_group_name: The name of the resource group. The name is case insensitive.
2836 Required.
2837 :type resource_group_name: str
2838 :param monitor_name: Monitor resource name. Required.
2839 :type monitor_name: str
2840 :param resource: The resource properties to be updated. Required.
2841 :type resource: IO[bytes]
2842 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
2843 Default value is "application/json".
2844 :paramtype content_type: str
2845 :return: MonitorResource. The MonitorResource is compatible with MutableMapping
2846 :rtype: ~azure.mgmt.dynatrace.models.MonitorResource
2847 :raises ~azure.core.exceptions.HttpResponseError:
2848 """
2850 @distributed_trace
2851 def update(
2852 self,
2853 resource_group_name: str,
2854 monitor_name: str,
2855 resource: Union[_models.MonitorResourceUpdate, _types.MonitorResourceUpdate, IO[bytes]],
2856 **kwargs: Any
2857 ) -> _models.MonitorResource:
2858 """Update a MonitorResource.
2860 :param resource_group_name: The name of the resource group. The name is case insensitive.
2861 Required.
2862 :type resource_group_name: str
2863 :param monitor_name: Monitor resource name. Required.
2864 :type monitor_name: str
2865 :param resource: The resource properties to be updated. Is either a MonitorResourceUpdate type
2866 or a IO[bytes] type. Required.
2867 :type resource: ~azure.mgmt.dynatrace.models.MonitorResourceUpdate or
2868 ~azure.mgmt.dynatrace.types.MonitorResourceUpdate or IO[bytes]
2869 :return: MonitorResource. The MonitorResource is compatible with MutableMapping
2870 :rtype: ~azure.mgmt.dynatrace.models.MonitorResource
2871 :raises ~azure.core.exceptions.HttpResponseError:
2872 """
2873 error_map: MutableMapping = {
2874 401: ClientAuthenticationError,
2875 404: ResourceNotFoundError,
2876 409: ResourceExistsError,
2877 304: ResourceNotModifiedError,
2878 }
2879 error_map.update(kwargs.pop("error_map", {}) or {})
2881 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
2882 _params = kwargs.pop("params", {}) or {}
2884 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
2885 cls: ClsType[_models.MonitorResource] = kwargs.pop("cls", None)
2887 content_type = content_type or "application/json"
2888 _content = None
2889 if isinstance(resource, (IOBase, bytes)):
2890 _content = resource
2891 else:
2892 _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
2894 _request = build_monitors_update_request(
2895 resource_group_name=resource_group_name,
2896 monitor_name=monitor_name,
2897 subscription_id=self._config.subscription_id,
2898 content_type=content_type,
2899 api_version=self._config.api_version,
2900 content=_content,
2901 headers=_headers,
2902 params=_params,
2903 )
2904 path_format_arguments = {
2905 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2906 }
2907 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2909 _decompress = kwargs.pop("decompress", True)
2910 _stream = kwargs.pop("stream", False)
2911 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2912 _request, stream=_stream, **kwargs
2913 )
2915 response = pipeline_response.http_response
2917 if response.status_code not in [200]:
2918 if _stream:
2919 try:
2920 response.read() # Load the body in memory and close the socket
2921 except (StreamConsumedError, StreamClosedError):
2922 pass
2923 map_error(status_code=response.status_code, response=response, error_map=error_map)
2924 error = _failsafe_deserialize(
2925 _models.ErrorResponse,
2926 response,
2927 )
2928 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2930 if _stream:
2931 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2932 else:
2933 deserialized = _deserialize(_models.MonitorResource, response.json())
2935 if cls:
2936 return cls(pipeline_response, deserialized, {}) # type: ignore
2938 return deserialized # type: ignore
2940 def _delete_initial(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> Iterator[bytes]:
2941 error_map: MutableMapping = {
2942 401: ClientAuthenticationError,
2943 404: ResourceNotFoundError,
2944 409: ResourceExistsError,
2945 304: ResourceNotModifiedError,
2946 }
2947 error_map.update(kwargs.pop("error_map", {}) or {})
2949 _headers = kwargs.pop("headers", {}) or {}
2950 _params = kwargs.pop("params", {}) or {}
2952 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
2954 _request = build_monitors_delete_request(
2955 resource_group_name=resource_group_name,
2956 monitor_name=monitor_name,
2957 subscription_id=self._config.subscription_id,
2958 api_version=self._config.api_version,
2959 headers=_headers,
2960 params=_params,
2961 )
2962 path_format_arguments = {
2963 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
2964 }
2965 _request.url = self._client.format_url(_request.url, **path_format_arguments)
2967 _decompress = kwargs.pop("decompress", True)
2968 _stream = True
2969 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
2970 _request, stream=_stream, **kwargs
2971 )
2973 response = pipeline_response.http_response
2975 if response.status_code not in [202, 204]:
2976 try:
2977 response.read() # Load the body in memory and close the socket
2978 except (StreamConsumedError, StreamClosedError):
2979 pass
2980 map_error(status_code=response.status_code, response=response, error_map=error_map)
2981 error = _failsafe_deserialize(
2982 _models.ErrorResponse,
2983 response,
2984 )
2985 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
2987 response_headers = {}
2988 if response.status_code == 202:
2989 response_headers["Azure-AsyncOperation"] = self._deserialize(
2990 "str", response.headers.get("Azure-AsyncOperation")
2991 )
2992 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
2993 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
2995 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
2997 if cls:
2998 return cls(pipeline_response, deserialized, response_headers) # type: ignore
3000 return deserialized # type: ignore
3002 @distributed_trace
3003 def begin_delete(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> LROPoller[None]:
3004 """Delete a MonitorResource.
3006 :param resource_group_name: The name of the resource group. The name is case insensitive.
3007 Required.
3008 :type resource_group_name: str
3009 :param monitor_name: Monitor resource name. Required.
3010 :type monitor_name: str
3011 :return: An instance of LROPoller that returns None
3012 :rtype: ~azure.core.polling.LROPoller[None]
3013 :raises ~azure.core.exceptions.HttpResponseError:
3014 """
3015 _headers = kwargs.pop("headers", {}) or {}
3016 _params = kwargs.pop("params", {}) or {}
3018 cls: ClsType[None] = kwargs.pop("cls", None)
3019 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
3020 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
3021 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
3022 if cont_token is None:
3023 raw_result = self._delete_initial(
3024 resource_group_name=resource_group_name,
3025 monitor_name=monitor_name,
3026 cls=lambda x, y, z: x,
3027 headers=_headers,
3028 params=_params,
3029 **kwargs
3030 )
3031 raw_result.http_response.read() # type: ignore
3032 kwargs.pop("error_map", None)
3034 def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements
3035 if cls:
3036 return cls(pipeline_response, None, {}) # type: ignore
3038 path_format_arguments = {
3039 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
3040 }
3042 if polling is True:
3043 polling_method: PollingMethod = cast(
3044 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
3045 )
3046 elif polling is False:
3047 polling_method = cast(PollingMethod, NoPolling())
3048 else:
3049 polling_method = polling
3050 if cont_token:
3051 return LROPoller[None].from_continuation_token(
3052 polling_method=polling_method,
3053 continuation_token=cont_token,
3054 client=self._client,
3055 deserialization_callback=get_long_running_output,
3056 )
3057 return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
3059 @distributed_trace
3060 def list_by_resource_group(self, resource_group_name: str, **kwargs: Any) -> ItemPaged["_models.MonitorResource"]:
3061 """List MonitorResource resources by resource group.
3063 :param resource_group_name: The name of the resource group. The name is case insensitive.
3064 Required.
3065 :type resource_group_name: str
3066 :return: An iterator like instance of MonitorResource
3067 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitorResource]
3068 :raises ~azure.core.exceptions.HttpResponseError:
3069 """
3070 _headers = kwargs.pop("headers", {}) or {}
3071 _params = kwargs.pop("params", {}) or {}
3073 cls: ClsType[List[_models.MonitorResource]] = kwargs.pop("cls", None)
3075 error_map: MutableMapping = {
3076 401: ClientAuthenticationError,
3077 404: ResourceNotFoundError,
3078 409: ResourceExistsError,
3079 304: ResourceNotModifiedError,
3080 }
3081 error_map.update(kwargs.pop("error_map", {}) or {})
3083 def prepare_request(next_link=None):
3084 if not next_link:
3086 _request = build_monitors_list_by_resource_group_request(
3087 resource_group_name=resource_group_name,
3088 subscription_id=self._config.subscription_id,
3089 api_version=self._config.api_version,
3090 headers=_headers,
3091 params=_params,
3092 )
3093 path_format_arguments = {
3094 "endpoint": self._serialize.url(
3095 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3096 ),
3097 }
3098 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3100 else:
3101 # make call to next link with the client's api-version
3102 _parsed_next_link = urllib.parse.urlparse(next_link)
3103 _next_request_params = case_insensitive_dict(
3104 {
3105 key: [urllib.parse.quote(v) for v in value]
3106 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
3107 }
3108 )
3109 _next_request_params["api-version"] = self._config.api_version
3110 _request = HttpRequest(
3111 "GET",
3112 urllib.parse.urljoin(next_link, _parsed_next_link.path),
3113 headers=_headers,
3114 params=_next_request_params,
3115 )
3116 path_format_arguments = {
3117 "endpoint": self._serialize.url(
3118 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3119 ),
3120 }
3121 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3123 return _request
3125 def extract_data(pipeline_response):
3126 deserialized = pipeline_response.http_response.json()
3127 list_of_elem = _deserialize(
3128 List[_models.MonitorResource],
3129 deserialized.get("value", []),
3130 )
3131 if cls:
3132 list_of_elem = cls(list_of_elem) # type: ignore
3133 return deserialized.get("nextLink") or None, iter(list_of_elem)
3135 def get_next(next_link=None):
3136 _request = prepare_request(next_link)
3138 _stream = False
3139 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3140 _request, stream=_stream, **kwargs
3141 )
3142 response = pipeline_response.http_response
3144 if response.status_code not in [200]:
3145 map_error(status_code=response.status_code, response=response, error_map=error_map)
3146 error = _failsafe_deserialize(
3147 _models.ErrorResponse,
3148 response,
3149 )
3150 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3152 return pipeline_response
3154 return ItemPaged(get_next, extract_data)
3156 @distributed_trace
3157 def list_by_subscription_id(self, **kwargs: Any) -> ItemPaged["_models.MonitorResource"]:
3158 """List all MonitorResource by subscriptionId.
3160 :return: An iterator like instance of MonitorResource
3161 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitorResource]
3162 :raises ~azure.core.exceptions.HttpResponseError:
3163 """
3164 _headers = kwargs.pop("headers", {}) or {}
3165 _params = kwargs.pop("params", {}) or {}
3167 cls: ClsType[List[_models.MonitorResource]] = kwargs.pop("cls", None)
3169 error_map: MutableMapping = {
3170 401: ClientAuthenticationError,
3171 404: ResourceNotFoundError,
3172 409: ResourceExistsError,
3173 304: ResourceNotModifiedError,
3174 }
3175 error_map.update(kwargs.pop("error_map", {}) or {})
3177 def prepare_request(next_link=None):
3178 if not next_link:
3180 _request = build_monitors_list_by_subscription_id_request(
3181 subscription_id=self._config.subscription_id,
3182 api_version=self._config.api_version,
3183 headers=_headers,
3184 params=_params,
3185 )
3186 path_format_arguments = {
3187 "endpoint": self._serialize.url(
3188 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3189 ),
3190 }
3191 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3193 else:
3194 # make call to next link with the client's api-version
3195 _parsed_next_link = urllib.parse.urlparse(next_link)
3196 _next_request_params = case_insensitive_dict(
3197 {
3198 key: [urllib.parse.quote(v) for v in value]
3199 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
3200 }
3201 )
3202 _next_request_params["api-version"] = self._config.api_version
3203 _request = HttpRequest(
3204 "GET",
3205 urllib.parse.urljoin(next_link, _parsed_next_link.path),
3206 headers=_headers,
3207 params=_next_request_params,
3208 )
3209 path_format_arguments = {
3210 "endpoint": self._serialize.url(
3211 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3212 ),
3213 }
3214 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3216 return _request
3218 def extract_data(pipeline_response):
3219 deserialized = pipeline_response.http_response.json()
3220 list_of_elem = _deserialize(
3221 List[_models.MonitorResource],
3222 deserialized.get("value", []),
3223 )
3224 if cls:
3225 list_of_elem = cls(list_of_elem) # type: ignore
3226 return deserialized.get("nextLink") or None, iter(list_of_elem)
3228 def get_next(next_link=None):
3229 _request = prepare_request(next_link)
3231 _stream = False
3232 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3233 _request, stream=_stream, **kwargs
3234 )
3235 response = pipeline_response.http_response
3237 if response.status_code not in [200]:
3238 map_error(status_code=response.status_code, response=response, error_map=error_map)
3239 error = _failsafe_deserialize(
3240 _models.ErrorResponse,
3241 response,
3242 )
3243 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3245 return pipeline_response
3247 return ItemPaged(get_next, extract_data)
3249 @overload
3250 def list_monitored_resources(
3251 self,
3252 resource_group_name: str,
3253 monitor_name: str,
3254 request: Optional[_models.LogStatusRequest] = None,
3255 *,
3256 content_type: str = "application/json",
3257 **kwargs: Any
3258 ) -> ItemPaged["_models.MonitoredResource"]:
3259 """List the resources currently being monitored by the Dynatrace monitor resource.
3261 :param resource_group_name: The name of the resource group. The name is case insensitive.
3262 Required.
3263 :type resource_group_name: str
3264 :param monitor_name: Monitor resource name. Required.
3265 :type monitor_name: str
3266 :param request: The details of the log status request. Default value is None.
3267 :type request: ~azure.mgmt.dynatrace.models.LogStatusRequest
3268 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3269 Default value is "application/json".
3270 :paramtype content_type: str
3271 :return: An iterator like instance of MonitoredResource
3272 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitoredResource]
3273 :raises ~azure.core.exceptions.HttpResponseError:
3274 """
3276 @overload
3277 def list_monitored_resources(
3278 self,
3279 resource_group_name: str,
3280 monitor_name: str,
3281 request: Optional[_types.LogStatusRequest] = None,
3282 *,
3283 content_type: str = "application/json",
3284 **kwargs: Any
3285 ) -> ItemPaged["_models.MonitoredResource"]:
3286 """List the resources currently being monitored by the Dynatrace monitor resource.
3288 :param resource_group_name: The name of the resource group. The name is case insensitive.
3289 Required.
3290 :type resource_group_name: str
3291 :param monitor_name: Monitor resource name. Required.
3292 :type monitor_name: str
3293 :param request: The details of the log status request. Default value is None.
3294 :type request: ~azure.mgmt.dynatrace.types.LogStatusRequest
3295 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3296 Default value is "application/json".
3297 :paramtype content_type: str
3298 :return: An iterator like instance of MonitoredResource
3299 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitoredResource]
3300 :raises ~azure.core.exceptions.HttpResponseError:
3301 """
3303 @overload
3304 def list_monitored_resources(
3305 self,
3306 resource_group_name: str,
3307 monitor_name: str,
3308 request: Optional[IO[bytes]] = None,
3309 *,
3310 content_type: str = "application/json",
3311 **kwargs: Any
3312 ) -> ItemPaged["_models.MonitoredResource"]:
3313 """List the resources currently being monitored by the Dynatrace monitor resource.
3315 :param resource_group_name: The name of the resource group. The name is case insensitive.
3316 Required.
3317 :type resource_group_name: str
3318 :param monitor_name: Monitor resource name. Required.
3319 :type monitor_name: str
3320 :param request: The details of the log status request. Default value is None.
3321 :type request: IO[bytes]
3322 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
3323 Default value is "application/json".
3324 :paramtype content_type: str
3325 :return: An iterator like instance of MonitoredResource
3326 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitoredResource]
3327 :raises ~azure.core.exceptions.HttpResponseError:
3328 """
3330 @distributed_trace
3331 def list_monitored_resources(
3332 self,
3333 resource_group_name: str,
3334 monitor_name: str,
3335 request: Optional[Union[_models.LogStatusRequest, _types.LogStatusRequest, IO[bytes]]] = None,
3336 **kwargs: Any
3337 ) -> ItemPaged["_models.MonitoredResource"]:
3338 """List the resources currently being monitored by the Dynatrace monitor resource.
3340 :param resource_group_name: The name of the resource group. The name is case insensitive.
3341 Required.
3342 :type resource_group_name: str
3343 :param monitor_name: Monitor resource name. Required.
3344 :type monitor_name: str
3345 :param request: The details of the log status request. Is either a LogStatusRequest type or a
3346 IO[bytes] type. Default value is None.
3347 :type request: ~azure.mgmt.dynatrace.models.LogStatusRequest or
3348 ~azure.mgmt.dynatrace.types.LogStatusRequest or IO[bytes]
3349 :return: An iterator like instance of MonitoredResource
3350 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.MonitoredResource]
3351 :raises ~azure.core.exceptions.HttpResponseError:
3352 """
3353 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
3354 _params = kwargs.pop("params", {}) or {}
3356 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
3357 content_type = content_type if request else None
3358 cls: ClsType[List[_models.MonitoredResource]] = kwargs.pop("cls", None)
3360 error_map: MutableMapping = {
3361 401: ClientAuthenticationError,
3362 404: ResourceNotFoundError,
3363 409: ResourceExistsError,
3364 304: ResourceNotModifiedError,
3365 }
3366 error_map.update(kwargs.pop("error_map", {}) or {})
3367 content_type = content_type or "application/json" if request else None
3368 _content = None
3369 if isinstance(request, (IOBase, bytes)):
3370 _content = request
3371 else:
3372 if request is not None:
3373 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
3374 else:
3375 _content = None
3377 def prepare_request(next_link=None):
3378 if not next_link:
3380 _request = build_monitors_list_monitored_resources_request(
3381 resource_group_name=resource_group_name,
3382 monitor_name=monitor_name,
3383 subscription_id=self._config.subscription_id,
3384 content_type=content_type,
3385 api_version=self._config.api_version,
3386 content=_content,
3387 headers=_headers,
3388 params=_params,
3389 )
3390 path_format_arguments = {
3391 "endpoint": self._serialize.url(
3392 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3393 ),
3394 }
3395 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3397 else:
3398 # make call to next link with the client's api-version
3399 _parsed_next_link = urllib.parse.urlparse(next_link)
3400 _next_request_params = case_insensitive_dict(
3401 {
3402 key: [urllib.parse.quote(v) for v in value]
3403 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
3404 }
3405 )
3406 _next_request_params["api-version"] = self._config.api_version
3407 _request = HttpRequest(
3408 "GET",
3409 urllib.parse.urljoin(next_link, _parsed_next_link.path),
3410 headers=_headers,
3411 params=_next_request_params,
3412 )
3413 path_format_arguments = {
3414 "endpoint": self._serialize.url(
3415 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3416 ),
3417 }
3418 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3420 return _request
3422 def extract_data(pipeline_response):
3423 deserialized = pipeline_response.http_response.json()
3424 list_of_elem = _deserialize(
3425 List[_models.MonitoredResource],
3426 deserialized.get("value", []),
3427 )
3428 if cls:
3429 list_of_elem = cls(list_of_elem) # type: ignore
3430 return deserialized.get("nextLink") or None, iter(list_of_elem)
3432 def get_next(next_link=None):
3433 _request = prepare_request(next_link)
3435 _stream = False
3436 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3437 _request, stream=_stream, **kwargs
3438 )
3439 response = pipeline_response.http_response
3441 if response.status_code not in [200]:
3442 map_error(status_code=response.status_code, response=response, error_map=error_map)
3443 error = _failsafe_deserialize(
3444 _models.ErrorResponse,
3445 response,
3446 )
3447 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3449 return pipeline_response
3451 return ItemPaged(get_next, extract_data)
3453 @distributed_trace
3454 def get_vm_host_payload(
3455 self, resource_group_name: str, monitor_name: str, **kwargs: Any
3456 ) -> _models.VMExtensionPayload:
3457 """Returns the payload that needs to be passed in the request body for installing Dynatrace agent
3458 on a VM.
3460 :param resource_group_name: The name of the resource group. The name is case insensitive.
3461 Required.
3462 :type resource_group_name: str
3463 :param monitor_name: Monitor resource name. Required.
3464 :type monitor_name: str
3465 :return: VMExtensionPayload. The VMExtensionPayload is compatible with MutableMapping
3466 :rtype: ~azure.mgmt.dynatrace.models.VMExtensionPayload
3467 :raises ~azure.core.exceptions.HttpResponseError:
3468 """
3469 error_map: MutableMapping = {
3470 401: ClientAuthenticationError,
3471 404: ResourceNotFoundError,
3472 409: ResourceExistsError,
3473 304: ResourceNotModifiedError,
3474 }
3475 error_map.update(kwargs.pop("error_map", {}) or {})
3477 _headers = kwargs.pop("headers", {}) or {}
3478 _params = kwargs.pop("params", {}) or {}
3480 cls: ClsType[_models.VMExtensionPayload] = kwargs.pop("cls", None)
3482 _request = build_monitors_get_vm_host_payload_request(
3483 resource_group_name=resource_group_name,
3484 monitor_name=monitor_name,
3485 subscription_id=self._config.subscription_id,
3486 api_version=self._config.api_version,
3487 headers=_headers,
3488 params=_params,
3489 )
3490 path_format_arguments = {
3491 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
3492 }
3493 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3495 _decompress = kwargs.pop("decompress", True)
3496 _stream = kwargs.pop("stream", False)
3497 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3498 _request, stream=_stream, **kwargs
3499 )
3501 response = pipeline_response.http_response
3503 if response.status_code not in [200]:
3504 if _stream:
3505 try:
3506 response.read() # Load the body in memory and close the socket
3507 except (StreamConsumedError, StreamClosedError):
3508 pass
3509 map_error(status_code=response.status_code, response=response, error_map=error_map)
3510 error = _failsafe_deserialize(
3511 _models.ErrorResponse,
3512 response,
3513 )
3514 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3516 if _stream:
3517 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
3518 else:
3519 deserialized = _deserialize(_models.VMExtensionPayload, response.json())
3521 if cls:
3522 return cls(pipeline_response, deserialized, {}) # type: ignore
3524 return deserialized # type: ignore
3526 @overload
3527 def manage_agent_installation(
3528 self,
3529 resource_group_name: str,
3530 monitor_name: str,
3531 request: _models.ManageAgentInstallationRequest,
3532 *,
3533 content_type: str = "application/json",
3534 **kwargs: Any
3535 ) -> None:
3536 """Performs Dynatrace agent install/uninstall action through the Azure Dynatrace resource on the
3537 provided list of resources.
3539 :param resource_group_name: The name of the resource group. The name is case insensitive.
3540 Required.
3541 :type resource_group_name: str
3542 :param monitor_name: Monitor resource name. Required.
3543 :type monitor_name: str
3544 :param request: List of resources and action. Required.
3545 :type request: ~azure.mgmt.dynatrace.models.ManageAgentInstallationRequest
3546 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3547 Default value is "application/json".
3548 :paramtype content_type: str
3549 :return: None
3550 :rtype: None
3551 :raises ~azure.core.exceptions.HttpResponseError:
3552 """
3554 @overload
3555 def manage_agent_installation(
3556 self,
3557 resource_group_name: str,
3558 monitor_name: str,
3559 request: _types.ManageAgentInstallationRequest,
3560 *,
3561 content_type: str = "application/json",
3562 **kwargs: Any
3563 ) -> None:
3564 """Performs Dynatrace agent install/uninstall action through the Azure Dynatrace resource on the
3565 provided list of resources.
3567 :param resource_group_name: The name of the resource group. The name is case insensitive.
3568 Required.
3569 :type resource_group_name: str
3570 :param monitor_name: Monitor resource name. Required.
3571 :type monitor_name: str
3572 :param request: List of resources and action. Required.
3573 :type request: ~azure.mgmt.dynatrace.types.ManageAgentInstallationRequest
3574 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3575 Default value is "application/json".
3576 :paramtype content_type: str
3577 :return: None
3578 :rtype: None
3579 :raises ~azure.core.exceptions.HttpResponseError:
3580 """
3582 @overload
3583 def manage_agent_installation(
3584 self,
3585 resource_group_name: str,
3586 monitor_name: str,
3587 request: IO[bytes],
3588 *,
3589 content_type: str = "application/json",
3590 **kwargs: Any
3591 ) -> None:
3592 """Performs Dynatrace agent install/uninstall action through the Azure Dynatrace resource on the
3593 provided list of resources.
3595 :param resource_group_name: The name of the resource group. The name is case insensitive.
3596 Required.
3597 :type resource_group_name: str
3598 :param monitor_name: Monitor resource name. Required.
3599 :type monitor_name: str
3600 :param request: List of resources and action. Required.
3601 :type request: IO[bytes]
3602 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
3603 Default value is "application/json".
3604 :paramtype content_type: str
3605 :return: None
3606 :rtype: None
3607 :raises ~azure.core.exceptions.HttpResponseError:
3608 """
3610 @distributed_trace
3611 def manage_agent_installation( # pylint: disable=inconsistent-return-statements
3612 self,
3613 resource_group_name: str,
3614 monitor_name: str,
3615 request: Union[_models.ManageAgentInstallationRequest, _types.ManageAgentInstallationRequest, IO[bytes]],
3616 **kwargs: Any
3617 ) -> None:
3618 """Performs Dynatrace agent install/uninstall action through the Azure Dynatrace resource on the
3619 provided list of resources.
3621 :param resource_group_name: The name of the resource group. The name is case insensitive.
3622 Required.
3623 :type resource_group_name: str
3624 :param monitor_name: Monitor resource name. Required.
3625 :type monitor_name: str
3626 :param request: List of resources and action. Is either a ManageAgentInstallationRequest type
3627 or a IO[bytes] type. Required.
3628 :type request: ~azure.mgmt.dynatrace.models.ManageAgentInstallationRequest or
3629 ~azure.mgmt.dynatrace.types.ManageAgentInstallationRequest or IO[bytes]
3630 :return: None
3631 :rtype: None
3632 :raises ~azure.core.exceptions.HttpResponseError:
3633 """
3634 error_map: MutableMapping = {
3635 401: ClientAuthenticationError,
3636 404: ResourceNotFoundError,
3637 409: ResourceExistsError,
3638 304: ResourceNotModifiedError,
3639 }
3640 error_map.update(kwargs.pop("error_map", {}) or {})
3642 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
3643 _params = kwargs.pop("params", {}) or {}
3645 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
3646 cls: ClsType[None] = kwargs.pop("cls", None)
3648 content_type = content_type or "application/json"
3649 _content = None
3650 if isinstance(request, (IOBase, bytes)):
3651 _content = request
3652 else:
3653 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
3655 _request = build_monitors_manage_agent_installation_request(
3656 resource_group_name=resource_group_name,
3657 monitor_name=monitor_name,
3658 subscription_id=self._config.subscription_id,
3659 content_type=content_type,
3660 api_version=self._config.api_version,
3661 content=_content,
3662 headers=_headers,
3663 params=_params,
3664 )
3665 path_format_arguments = {
3666 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
3667 }
3668 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3670 _stream = False
3671 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3672 _request, stream=_stream, **kwargs
3673 )
3675 response = pipeline_response.http_response
3677 if response.status_code not in [204]:
3678 map_error(status_code=response.status_code, response=response, error_map=error_map)
3679 error = _failsafe_deserialize(
3680 _models.ErrorResponse,
3681 response,
3682 )
3683 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3685 if cls:
3686 return cls(pipeline_response, None, {}) # type: ignore
3688 @distributed_trace
3689 def list_hosts(self, resource_group_name: str, monitor_name: str, **kwargs: Any) -> ItemPaged["_models.VMInfo"]:
3690 """List the VM/VMSS resources currently being monitored by the Dynatrace resource.
3692 :param resource_group_name: The name of the resource group. The name is case insensitive.
3693 Required.
3694 :type resource_group_name: str
3695 :param monitor_name: Monitor resource name. Required.
3696 :type monitor_name: str
3697 :return: An iterator like instance of VMInfo
3698 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.VMInfo]
3699 :raises ~azure.core.exceptions.HttpResponseError:
3700 """
3701 _headers = kwargs.pop("headers", {}) or {}
3702 _params = kwargs.pop("params", {}) or {}
3704 cls: ClsType[List[_models.VMInfo]] = kwargs.pop("cls", None)
3706 error_map: MutableMapping = {
3707 401: ClientAuthenticationError,
3708 404: ResourceNotFoundError,
3709 409: ResourceExistsError,
3710 304: ResourceNotModifiedError,
3711 }
3712 error_map.update(kwargs.pop("error_map", {}) or {})
3714 def prepare_request(next_link=None):
3715 if not next_link:
3717 _request = build_monitors_list_hosts_request(
3718 resource_group_name=resource_group_name,
3719 monitor_name=monitor_name,
3720 subscription_id=self._config.subscription_id,
3721 api_version=self._config.api_version,
3722 headers=_headers,
3723 params=_params,
3724 )
3725 path_format_arguments = {
3726 "endpoint": self._serialize.url(
3727 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3728 ),
3729 }
3730 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3732 else:
3733 # make call to next link with the client's api-version
3734 _parsed_next_link = urllib.parse.urlparse(next_link)
3735 _next_request_params = case_insensitive_dict(
3736 {
3737 key: [urllib.parse.quote(v) for v in value]
3738 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
3739 }
3740 )
3741 _next_request_params["api-version"] = self._config.api_version
3742 _request = HttpRequest(
3743 "GET",
3744 urllib.parse.urljoin(next_link, _parsed_next_link.path),
3745 headers=_headers,
3746 params=_next_request_params,
3747 )
3748 path_format_arguments = {
3749 "endpoint": self._serialize.url(
3750 "self._config.base_url", self._config.base_url, "str", skip_quote=True
3751 ),
3752 }
3753 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3755 return _request
3757 def extract_data(pipeline_response):
3758 deserialized = pipeline_response.http_response.json()
3759 list_of_elem = _deserialize(
3760 List[_models.VMInfo],
3761 deserialized.get("value", []),
3762 )
3763 if cls:
3764 list_of_elem = cls(list_of_elem) # type: ignore
3765 return deserialized.get("nextLink") or None, iter(list_of_elem)
3767 def get_next(next_link=None):
3768 _request = prepare_request(next_link)
3770 _stream = False
3771 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3772 _request, stream=_stream, **kwargs
3773 )
3774 response = pipeline_response.http_response
3776 if response.status_code not in [200]:
3777 map_error(status_code=response.status_code, response=response, error_map=error_map)
3778 error = _failsafe_deserialize(
3779 _models.ErrorResponse,
3780 response,
3781 )
3782 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3784 return pipeline_response
3786 return ItemPaged(get_next, extract_data)
3788 @overload
3789 def get_metric_status(
3790 self,
3791 resource_group_name: str,
3792 monitor_name: str,
3793 request: Optional[_models.MetricStatusRequest] = None,
3794 *,
3795 content_type: str = "application/json",
3796 **kwargs: Any
3797 ) -> _models.MetricsStatusResponse:
3798 """Get metric status.
3800 :param resource_group_name: The name of the resource group. The name is case insensitive.
3801 Required.
3802 :type resource_group_name: str
3803 :param monitor_name: Monitor resource name. Required.
3804 :type monitor_name: str
3805 :param request: The details of the metric status request. Default value is None.
3806 :type request: ~azure.mgmt.dynatrace.models.MetricStatusRequest
3807 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3808 Default value is "application/json".
3809 :paramtype content_type: str
3810 :return: MetricsStatusResponse. The MetricsStatusResponse is compatible with MutableMapping
3811 :rtype: ~azure.mgmt.dynatrace.models.MetricsStatusResponse
3812 :raises ~azure.core.exceptions.HttpResponseError:
3813 """
3815 @overload
3816 def get_metric_status(
3817 self,
3818 resource_group_name: str,
3819 monitor_name: str,
3820 request: Optional[_types.MetricStatusRequest] = None,
3821 *,
3822 content_type: str = "application/json",
3823 **kwargs: Any
3824 ) -> _models.MetricsStatusResponse:
3825 """Get metric status.
3827 :param resource_group_name: The name of the resource group. The name is case insensitive.
3828 Required.
3829 :type resource_group_name: str
3830 :param monitor_name: Monitor resource name. Required.
3831 :type monitor_name: str
3832 :param request: The details of the metric status request. Default value is None.
3833 :type request: ~azure.mgmt.dynatrace.types.MetricStatusRequest
3834 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
3835 Default value is "application/json".
3836 :paramtype content_type: str
3837 :return: MetricsStatusResponse. The MetricsStatusResponse is compatible with MutableMapping
3838 :rtype: ~azure.mgmt.dynatrace.models.MetricsStatusResponse
3839 :raises ~azure.core.exceptions.HttpResponseError:
3840 """
3842 @overload
3843 def get_metric_status(
3844 self,
3845 resource_group_name: str,
3846 monitor_name: str,
3847 request: Optional[IO[bytes]] = None,
3848 *,
3849 content_type: str = "application/json",
3850 **kwargs: Any
3851 ) -> _models.MetricsStatusResponse:
3852 """Get metric status.
3854 :param resource_group_name: The name of the resource group. The name is case insensitive.
3855 Required.
3856 :type resource_group_name: str
3857 :param monitor_name: Monitor resource name. Required.
3858 :type monitor_name: str
3859 :param request: The details of the metric status request. Default value is None.
3860 :type request: IO[bytes]
3861 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
3862 Default value is "application/json".
3863 :paramtype content_type: str
3864 :return: MetricsStatusResponse. The MetricsStatusResponse is compatible with MutableMapping
3865 :rtype: ~azure.mgmt.dynatrace.models.MetricsStatusResponse
3866 :raises ~azure.core.exceptions.HttpResponseError:
3867 """
3869 @distributed_trace
3870 def get_metric_status(
3871 self,
3872 resource_group_name: str,
3873 monitor_name: str,
3874 request: Optional[Union[_models.MetricStatusRequest, _types.MetricStatusRequest, IO[bytes]]] = None,
3875 **kwargs: Any
3876 ) -> _models.MetricsStatusResponse:
3877 """Get metric status.
3879 :param resource_group_name: The name of the resource group. The name is case insensitive.
3880 Required.
3881 :type resource_group_name: str
3882 :param monitor_name: Monitor resource name. Required.
3883 :type monitor_name: str
3884 :param request: The details of the metric status request. Is either a MetricStatusRequest type
3885 or a IO[bytes] type. Default value is None.
3886 :type request: ~azure.mgmt.dynatrace.models.MetricStatusRequest or
3887 ~azure.mgmt.dynatrace.types.MetricStatusRequest or IO[bytes]
3888 :return: MetricsStatusResponse. The MetricsStatusResponse is compatible with MutableMapping
3889 :rtype: ~azure.mgmt.dynatrace.models.MetricsStatusResponse
3890 :raises ~azure.core.exceptions.HttpResponseError:
3891 """
3892 error_map: MutableMapping = {
3893 401: ClientAuthenticationError,
3894 404: ResourceNotFoundError,
3895 409: ResourceExistsError,
3896 304: ResourceNotModifiedError,
3897 }
3898 error_map.update(kwargs.pop("error_map", {}) or {})
3900 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
3901 _params = kwargs.pop("params", {}) or {}
3903 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
3904 content_type = content_type if request else None
3905 cls: ClsType[_models.MetricsStatusResponse] = kwargs.pop("cls", None)
3907 content_type = content_type or "application/json" if request else None
3908 _content = None
3909 if isinstance(request, (IOBase, bytes)):
3910 _content = request
3911 else:
3912 if request is not None:
3913 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
3914 else:
3915 _content = None
3917 _request = build_monitors_get_metric_status_request(
3918 resource_group_name=resource_group_name,
3919 monitor_name=monitor_name,
3920 subscription_id=self._config.subscription_id,
3921 content_type=content_type,
3922 api_version=self._config.api_version,
3923 content=_content,
3924 headers=_headers,
3925 params=_params,
3926 )
3927 path_format_arguments = {
3928 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
3929 }
3930 _request.url = self._client.format_url(_request.url, **path_format_arguments)
3932 _decompress = kwargs.pop("decompress", True)
3933 _stream = kwargs.pop("stream", False)
3934 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
3935 _request, stream=_stream, **kwargs
3936 )
3938 response = pipeline_response.http_response
3940 if response.status_code not in [200]:
3941 if _stream:
3942 try:
3943 response.read() # Load the body in memory and close the socket
3944 except (StreamConsumedError, StreamClosedError):
3945 pass
3946 map_error(status_code=response.status_code, response=response, error_map=error_map)
3947 error = _failsafe_deserialize(
3948 _models.ErrorResponse,
3949 response,
3950 )
3951 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
3953 if _stream:
3954 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
3955 else:
3956 deserialized = _deserialize(_models.MetricsStatusResponse, response.json())
3958 if cls:
3959 return cls(pipeline_response, deserialized, {}) # type: ignore
3961 return deserialized # type: ignore
3963 @distributed_trace
3964 def list_app_services(
3965 self, resource_group_name: str, monitor_name: str, **kwargs: Any
3966 ) -> ItemPaged["_models.AppServiceInfo"]:
3967 """Gets list of App Services with Dynatrace PaaS OneAgent enabled.
3969 :param resource_group_name: The name of the resource group. The name is case insensitive.
3970 Required.
3971 :type resource_group_name: str
3972 :param monitor_name: Monitor resource name. Required.
3973 :type monitor_name: str
3974 :return: An iterator like instance of AppServiceInfo
3975 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.AppServiceInfo]
3976 :raises ~azure.core.exceptions.HttpResponseError:
3977 """
3978 _headers = kwargs.pop("headers", {}) or {}
3979 _params = kwargs.pop("params", {}) or {}
3981 cls: ClsType[List[_models.AppServiceInfo]] = kwargs.pop("cls", None)
3983 error_map: MutableMapping = {
3984 401: ClientAuthenticationError,
3985 404: ResourceNotFoundError,
3986 409: ResourceExistsError,
3987 304: ResourceNotModifiedError,
3988 }
3989 error_map.update(kwargs.pop("error_map", {}) or {})
3991 def prepare_request(next_link=None):
3992 if not next_link:
3994 _request = build_monitors_list_app_services_request(
3995 resource_group_name=resource_group_name,
3996 monitor_name=monitor_name,
3997 subscription_id=self._config.subscription_id,
3998 api_version=self._config.api_version,
3999 headers=_headers,
4000 params=_params,
4001 )
4002 path_format_arguments = {
4003 "endpoint": self._serialize.url(
4004 "self._config.base_url", self._config.base_url, "str", skip_quote=True
4005 ),
4006 }
4007 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4009 else:
4010 # make call to next link with the client's api-version
4011 _parsed_next_link = urllib.parse.urlparse(next_link)
4012 _next_request_params = case_insensitive_dict(
4013 {
4014 key: [urllib.parse.quote(v) for v in value]
4015 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
4016 }
4017 )
4018 _next_request_params["api-version"] = self._config.api_version
4019 _request = HttpRequest(
4020 "GET",
4021 urllib.parse.urljoin(next_link, _parsed_next_link.path),
4022 headers=_headers,
4023 params=_next_request_params,
4024 )
4025 path_format_arguments = {
4026 "endpoint": self._serialize.url(
4027 "self._config.base_url", self._config.base_url, "str", skip_quote=True
4028 ),
4029 }
4030 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4032 return _request
4034 def extract_data(pipeline_response):
4035 deserialized = pipeline_response.http_response.json()
4036 list_of_elem = _deserialize(
4037 List[_models.AppServiceInfo],
4038 deserialized.get("value", []),
4039 )
4040 if cls:
4041 list_of_elem = cls(list_of_elem) # type: ignore
4042 return deserialized.get("nextLink") or None, iter(list_of_elem)
4044 def get_next(next_link=None):
4045 _request = prepare_request(next_link)
4047 _stream = False
4048 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4049 _request, stream=_stream, **kwargs
4050 )
4051 response = pipeline_response.http_response
4053 if response.status_code not in [200]:
4054 map_error(status_code=response.status_code, response=response, error_map=error_map)
4055 error = _failsafe_deserialize(
4056 _models.ErrorResponse,
4057 response,
4058 )
4059 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4061 return pipeline_response
4063 return ItemPaged(get_next, extract_data)
4065 def _upgrade_plan_initial(
4066 self,
4067 resource_group_name: str,
4068 monitor_name: str,
4069 request: Union[_models.UpgradePlanRequest, _types.UpgradePlanRequest, IO[bytes]],
4070 **kwargs: Any
4071 ) -> Iterator[bytes]:
4072 error_map: MutableMapping = {
4073 401: ClientAuthenticationError,
4074 404: ResourceNotFoundError,
4075 409: ResourceExistsError,
4076 304: ResourceNotModifiedError,
4077 }
4078 error_map.update(kwargs.pop("error_map", {}) or {})
4080 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4081 _params = kwargs.pop("params", {}) or {}
4083 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4084 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
4086 content_type = content_type or "application/json"
4087 _content = None
4088 if isinstance(request, (IOBase, bytes)):
4089 _content = request
4090 else:
4091 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
4093 _request = build_monitors_upgrade_plan_request(
4094 resource_group_name=resource_group_name,
4095 monitor_name=monitor_name,
4096 subscription_id=self._config.subscription_id,
4097 content_type=content_type,
4098 api_version=self._config.api_version,
4099 content=_content,
4100 headers=_headers,
4101 params=_params,
4102 )
4103 path_format_arguments = {
4104 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
4105 }
4106 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4108 _decompress = kwargs.pop("decompress", True)
4109 _stream = True
4110 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4111 _request, stream=_stream, **kwargs
4112 )
4114 response = pipeline_response.http_response
4116 if response.status_code not in [202]:
4117 try:
4118 response.read() # Load the body in memory and close the socket
4119 except (StreamConsumedError, StreamClosedError):
4120 pass
4121 map_error(status_code=response.status_code, response=response, error_map=error_map)
4122 error = _failsafe_deserialize(
4123 _models.ErrorResponse,
4124 response,
4125 )
4126 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4128 response_headers = {}
4129 response_headers["Location"] = self._deserialize("str", response.headers.get("Location"))
4130 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
4132 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
4134 if cls:
4135 return cls(pipeline_response, deserialized, response_headers) # type: ignore
4137 return deserialized # type: ignore
4139 @overload
4140 def begin_upgrade_plan(
4141 self,
4142 resource_group_name: str,
4143 monitor_name: str,
4144 request: _models.UpgradePlanRequest,
4145 *,
4146 content_type: str = "application/json",
4147 **kwargs: Any
4148 ) -> LROPoller[None]:
4149 """Upgrades the billing Plan for Dynatrace monitor resource.
4151 :param resource_group_name: The name of the resource group. The name is case insensitive.
4152 Required.
4153 :type resource_group_name: str
4154 :param monitor_name: Monitor resource name. Required.
4155 :type monitor_name: str
4156 :param request: The details of the upgrade plan request. Required.
4157 :type request: ~azure.mgmt.dynatrace.models.UpgradePlanRequest
4158 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4159 Default value is "application/json".
4160 :paramtype content_type: str
4161 :return: An instance of LROPoller that returns None
4162 :rtype: ~azure.core.polling.LROPoller[None]
4163 :raises ~azure.core.exceptions.HttpResponseError:
4164 """
4166 @overload
4167 def begin_upgrade_plan(
4168 self,
4169 resource_group_name: str,
4170 monitor_name: str,
4171 request: _types.UpgradePlanRequest,
4172 *,
4173 content_type: str = "application/json",
4174 **kwargs: Any
4175 ) -> LROPoller[None]:
4176 """Upgrades the billing Plan for Dynatrace monitor resource.
4178 :param resource_group_name: The name of the resource group. The name is case insensitive.
4179 Required.
4180 :type resource_group_name: str
4181 :param monitor_name: Monitor resource name. Required.
4182 :type monitor_name: str
4183 :param request: The details of the upgrade plan request. Required.
4184 :type request: ~azure.mgmt.dynatrace.types.UpgradePlanRequest
4185 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4186 Default value is "application/json".
4187 :paramtype content_type: str
4188 :return: An instance of LROPoller that returns None
4189 :rtype: ~azure.core.polling.LROPoller[None]
4190 :raises ~azure.core.exceptions.HttpResponseError:
4191 """
4193 @overload
4194 def begin_upgrade_plan(
4195 self,
4196 resource_group_name: str,
4197 monitor_name: str,
4198 request: IO[bytes],
4199 *,
4200 content_type: str = "application/json",
4201 **kwargs: Any
4202 ) -> LROPoller[None]:
4203 """Upgrades the billing Plan for Dynatrace monitor resource.
4205 :param resource_group_name: The name of the resource group. The name is case insensitive.
4206 Required.
4207 :type resource_group_name: str
4208 :param monitor_name: Monitor resource name. Required.
4209 :type monitor_name: str
4210 :param request: The details of the upgrade plan request. Required.
4211 :type request: IO[bytes]
4212 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
4213 Default value is "application/json".
4214 :paramtype content_type: str
4215 :return: An instance of LROPoller that returns None
4216 :rtype: ~azure.core.polling.LROPoller[None]
4217 :raises ~azure.core.exceptions.HttpResponseError:
4218 """
4220 @distributed_trace
4221 def begin_upgrade_plan(
4222 self,
4223 resource_group_name: str,
4224 monitor_name: str,
4225 request: Union[_models.UpgradePlanRequest, _types.UpgradePlanRequest, IO[bytes]],
4226 **kwargs: Any
4227 ) -> LROPoller[None]:
4228 """Upgrades the billing Plan for Dynatrace monitor resource.
4230 :param resource_group_name: The name of the resource group. The name is case insensitive.
4231 Required.
4232 :type resource_group_name: str
4233 :param monitor_name: Monitor resource name. Required.
4234 :type monitor_name: str
4235 :param request: The details of the upgrade plan request. Is either a UpgradePlanRequest type or
4236 a IO[bytes] type. Required.
4237 :type request: ~azure.mgmt.dynatrace.models.UpgradePlanRequest or
4238 ~azure.mgmt.dynatrace.types.UpgradePlanRequest or IO[bytes]
4239 :return: An instance of LROPoller that returns None
4240 :rtype: ~azure.core.polling.LROPoller[None]
4241 :raises ~azure.core.exceptions.HttpResponseError:
4242 """
4243 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4244 _params = kwargs.pop("params", {}) or {}
4246 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4247 cls: ClsType[None] = kwargs.pop("cls", None)
4248 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
4249 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
4250 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
4251 if cont_token is None:
4252 raw_result = self._upgrade_plan_initial(
4253 resource_group_name=resource_group_name,
4254 monitor_name=monitor_name,
4255 request=request,
4256 content_type=content_type,
4257 cls=lambda x, y, z: x,
4258 headers=_headers,
4259 params=_params,
4260 **kwargs
4261 )
4262 raw_result.http_response.read() # type: ignore
4263 kwargs.pop("error_map", None)
4265 def get_long_running_output(pipeline_response): # pylint: disable=inconsistent-return-statements
4266 if cls:
4267 return cls(pipeline_response, None, {}) # type: ignore
4269 path_format_arguments = {
4270 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
4271 }
4273 if polling is True:
4274 polling_method: PollingMethod = cast(
4275 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
4276 )
4277 elif polling is False:
4278 polling_method = cast(PollingMethod, NoPolling())
4279 else:
4280 polling_method = polling
4281 if cont_token:
4282 return LROPoller[None].from_continuation_token(
4283 polling_method=polling_method,
4284 continuation_token=cont_token,
4285 client=self._client,
4286 deserialization_callback=get_long_running_output,
4287 )
4288 return LROPoller[None](self._client, raw_result, get_long_running_output, polling_method) # type: ignore
4290 @overload
4291 def get_sso_details(
4292 self,
4293 resource_group_name: str,
4294 monitor_name: str,
4295 request: Optional[_models.SSODetailsRequest] = None,
4296 *,
4297 content_type: str = "application/json",
4298 **kwargs: Any
4299 ) -> _models.SSODetailsResponse:
4300 """Gets the SSO configuration details from the partner.
4302 :param resource_group_name: The name of the resource group. The name is case insensitive.
4303 Required.
4304 :type resource_group_name: str
4305 :param monitor_name: Monitor resource name. Required.
4306 :type monitor_name: str
4307 :param request: The details of the get sso details request. Default value is None.
4308 :type request: ~azure.mgmt.dynatrace.models.SSODetailsRequest
4309 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4310 Default value is "application/json".
4311 :paramtype content_type: str
4312 :return: SSODetailsResponse. The SSODetailsResponse is compatible with MutableMapping
4313 :rtype: ~azure.mgmt.dynatrace.models.SSODetailsResponse
4314 :raises ~azure.core.exceptions.HttpResponseError:
4315 """
4317 @overload
4318 def get_sso_details(
4319 self,
4320 resource_group_name: str,
4321 monitor_name: str,
4322 request: Optional[_types.SSODetailsRequest] = None,
4323 *,
4324 content_type: str = "application/json",
4325 **kwargs: Any
4326 ) -> _models.SSODetailsResponse:
4327 """Gets the SSO configuration details from the partner.
4329 :param resource_group_name: The name of the resource group. The name is case insensitive.
4330 Required.
4331 :type resource_group_name: str
4332 :param monitor_name: Monitor resource name. Required.
4333 :type monitor_name: str
4334 :param request: The details of the get sso details request. Default value is None.
4335 :type request: ~azure.mgmt.dynatrace.types.SSODetailsRequest
4336 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4337 Default value is "application/json".
4338 :paramtype content_type: str
4339 :return: SSODetailsResponse. The SSODetailsResponse is compatible with MutableMapping
4340 :rtype: ~azure.mgmt.dynatrace.models.SSODetailsResponse
4341 :raises ~azure.core.exceptions.HttpResponseError:
4342 """
4344 @overload
4345 def get_sso_details(
4346 self,
4347 resource_group_name: str,
4348 monitor_name: str,
4349 request: Optional[IO[bytes]] = None,
4350 *,
4351 content_type: str = "application/json",
4352 **kwargs: Any
4353 ) -> _models.SSODetailsResponse:
4354 """Gets the SSO configuration details from the partner.
4356 :param resource_group_name: The name of the resource group. The name is case insensitive.
4357 Required.
4358 :type resource_group_name: str
4359 :param monitor_name: Monitor resource name. Required.
4360 :type monitor_name: str
4361 :param request: The details of the get sso details request. Default value is None.
4362 :type request: IO[bytes]
4363 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
4364 Default value is "application/json".
4365 :paramtype content_type: str
4366 :return: SSODetailsResponse. The SSODetailsResponse is compatible with MutableMapping
4367 :rtype: ~azure.mgmt.dynatrace.models.SSODetailsResponse
4368 :raises ~azure.core.exceptions.HttpResponseError:
4369 """
4371 @distributed_trace
4372 def get_sso_details(
4373 self,
4374 resource_group_name: str,
4375 monitor_name: str,
4376 request: Optional[Union[_models.SSODetailsRequest, _types.SSODetailsRequest, IO[bytes]]] = None,
4377 **kwargs: Any
4378 ) -> _models.SSODetailsResponse:
4379 """Gets the SSO configuration details from the partner.
4381 :param resource_group_name: The name of the resource group. The name is case insensitive.
4382 Required.
4383 :type resource_group_name: str
4384 :param monitor_name: Monitor resource name. Required.
4385 :type monitor_name: str
4386 :param request: The details of the get sso details request. Is either a SSODetailsRequest type
4387 or a IO[bytes] type. Default value is None.
4388 :type request: ~azure.mgmt.dynatrace.models.SSODetailsRequest or
4389 ~azure.mgmt.dynatrace.types.SSODetailsRequest or IO[bytes]
4390 :return: SSODetailsResponse. The SSODetailsResponse is compatible with MutableMapping
4391 :rtype: ~azure.mgmt.dynatrace.models.SSODetailsResponse
4392 :raises ~azure.core.exceptions.HttpResponseError:
4393 """
4394 error_map: MutableMapping = {
4395 401: ClientAuthenticationError,
4396 404: ResourceNotFoundError,
4397 409: ResourceExistsError,
4398 304: ResourceNotModifiedError,
4399 }
4400 error_map.update(kwargs.pop("error_map", {}) or {})
4402 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4403 _params = kwargs.pop("params", {}) or {}
4405 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4406 content_type = content_type if request else None
4407 cls: ClsType[_models.SSODetailsResponse] = kwargs.pop("cls", None)
4409 content_type = content_type or "application/json" if request else None
4410 _content = None
4411 if isinstance(request, (IOBase, bytes)):
4412 _content = request
4413 else:
4414 if request is not None:
4415 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
4416 else:
4417 _content = None
4419 _request = build_monitors_get_sso_details_request(
4420 resource_group_name=resource_group_name,
4421 monitor_name=monitor_name,
4422 subscription_id=self._config.subscription_id,
4423 content_type=content_type,
4424 api_version=self._config.api_version,
4425 content=_content,
4426 headers=_headers,
4427 params=_params,
4428 )
4429 path_format_arguments = {
4430 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
4431 }
4432 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4434 _decompress = kwargs.pop("decompress", True)
4435 _stream = kwargs.pop("stream", False)
4436 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4437 _request, stream=_stream, **kwargs
4438 )
4440 response = pipeline_response.http_response
4442 if response.status_code not in [200]:
4443 if _stream:
4444 try:
4445 response.read() # Load the body in memory and close the socket
4446 except (StreamConsumedError, StreamClosedError):
4447 pass
4448 map_error(status_code=response.status_code, response=response, error_map=error_map)
4449 error = _failsafe_deserialize(
4450 _models.ErrorResponse,
4451 response,
4452 )
4453 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4455 if _stream:
4456 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
4457 else:
4458 deserialized = _deserialize(_models.SSODetailsResponse, response.json())
4460 if cls:
4461 return cls(pipeline_response, deserialized, {}) # type: ignore
4463 return deserialized # type: ignore
4465 @overload
4466 def list_linkable_environments(
4467 self,
4468 resource_group_name: str,
4469 monitor_name: str,
4470 request: _models.LinkableEnvironmentRequest,
4471 *,
4472 content_type: str = "application/json",
4473 **kwargs: Any
4474 ) -> ItemPaged["_models.LinkableEnvironmentResponse"]:
4475 """Gets all the Dynatrace environments that a user can link a azure resource to.
4477 :param resource_group_name: The name of the resource group. The name is case insensitive.
4478 Required.
4479 :type resource_group_name: str
4480 :param monitor_name: Monitor resource name. Required.
4481 :type monitor_name: str
4482 :param request: The details of the linkable environment request. Required.
4483 :type request: ~azure.mgmt.dynatrace.models.LinkableEnvironmentRequest
4484 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4485 Default value is "application/json".
4486 :paramtype content_type: str
4487 :return: An iterator like instance of LinkableEnvironmentResponse
4488 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.LinkableEnvironmentResponse]
4489 :raises ~azure.core.exceptions.HttpResponseError:
4490 """
4492 @overload
4493 def list_linkable_environments(
4494 self,
4495 resource_group_name: str,
4496 monitor_name: str,
4497 request: _types.LinkableEnvironmentRequest,
4498 *,
4499 content_type: str = "application/json",
4500 **kwargs: Any
4501 ) -> ItemPaged["_models.LinkableEnvironmentResponse"]:
4502 """Gets all the Dynatrace environments that a user can link a azure resource to.
4504 :param resource_group_name: The name of the resource group. The name is case insensitive.
4505 Required.
4506 :type resource_group_name: str
4507 :param monitor_name: Monitor resource name. Required.
4508 :type monitor_name: str
4509 :param request: The details of the linkable environment request. Required.
4510 :type request: ~azure.mgmt.dynatrace.types.LinkableEnvironmentRequest
4511 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4512 Default value is "application/json".
4513 :paramtype content_type: str
4514 :return: An iterator like instance of LinkableEnvironmentResponse
4515 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.LinkableEnvironmentResponse]
4516 :raises ~azure.core.exceptions.HttpResponseError:
4517 """
4519 @overload
4520 def list_linkable_environments(
4521 self,
4522 resource_group_name: str,
4523 monitor_name: str,
4524 request: IO[bytes],
4525 *,
4526 content_type: str = "application/json",
4527 **kwargs: Any
4528 ) -> ItemPaged["_models.LinkableEnvironmentResponse"]:
4529 """Gets all the Dynatrace environments that a user can link a azure resource to.
4531 :param resource_group_name: The name of the resource group. The name is case insensitive.
4532 Required.
4533 :type resource_group_name: str
4534 :param monitor_name: Monitor resource name. Required.
4535 :type monitor_name: str
4536 :param request: The details of the linkable environment request. Required.
4537 :type request: IO[bytes]
4538 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
4539 Default value is "application/json".
4540 :paramtype content_type: str
4541 :return: An iterator like instance of LinkableEnvironmentResponse
4542 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.LinkableEnvironmentResponse]
4543 :raises ~azure.core.exceptions.HttpResponseError:
4544 """
4546 @distributed_trace
4547 def list_linkable_environments(
4548 self,
4549 resource_group_name: str,
4550 monitor_name: str,
4551 request: Union[_models.LinkableEnvironmentRequest, _types.LinkableEnvironmentRequest, IO[bytes]],
4552 **kwargs: Any
4553 ) -> ItemPaged["_models.LinkableEnvironmentResponse"]:
4554 """Gets all the Dynatrace environments that a user can link a azure resource to.
4556 :param resource_group_name: The name of the resource group. The name is case insensitive.
4557 Required.
4558 :type resource_group_name: str
4559 :param monitor_name: Monitor resource name. Required.
4560 :type monitor_name: str
4561 :param request: The details of the linkable environment request. Is either a
4562 LinkableEnvironmentRequest type or a IO[bytes] type. Required.
4563 :type request: ~azure.mgmt.dynatrace.models.LinkableEnvironmentRequest or
4564 ~azure.mgmt.dynatrace.types.LinkableEnvironmentRequest or IO[bytes]
4565 :return: An iterator like instance of LinkableEnvironmentResponse
4566 :rtype: ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.LinkableEnvironmentResponse]
4567 :raises ~azure.core.exceptions.HttpResponseError:
4568 """
4569 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4570 _params = kwargs.pop("params", {}) or {}
4572 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4573 cls: ClsType[List[_models.LinkableEnvironmentResponse]] = kwargs.pop("cls", None)
4575 error_map: MutableMapping = {
4576 401: ClientAuthenticationError,
4577 404: ResourceNotFoundError,
4578 409: ResourceExistsError,
4579 304: ResourceNotModifiedError,
4580 }
4581 error_map.update(kwargs.pop("error_map", {}) or {})
4582 content_type = content_type or "application/json"
4583 _content = None
4584 if isinstance(request, (IOBase, bytes)):
4585 _content = request
4586 else:
4587 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
4589 def prepare_request(next_link=None):
4590 if not next_link:
4592 _request = build_monitors_list_linkable_environments_request(
4593 resource_group_name=resource_group_name,
4594 monitor_name=monitor_name,
4595 subscription_id=self._config.subscription_id,
4596 content_type=content_type,
4597 api_version=self._config.api_version,
4598 content=_content,
4599 headers=_headers,
4600 params=_params,
4601 )
4602 path_format_arguments = {
4603 "endpoint": self._serialize.url(
4604 "self._config.base_url", self._config.base_url, "str", skip_quote=True
4605 ),
4606 }
4607 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4609 else:
4610 # make call to next link with the client's api-version
4611 _parsed_next_link = urllib.parse.urlparse(next_link)
4612 _next_request_params = case_insensitive_dict(
4613 {
4614 key: [urllib.parse.quote(v) for v in value]
4615 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
4616 }
4617 )
4618 _next_request_params["api-version"] = self._config.api_version
4619 _request = HttpRequest(
4620 "GET",
4621 urllib.parse.urljoin(next_link, _parsed_next_link.path),
4622 headers=_headers,
4623 params=_next_request_params,
4624 )
4625 path_format_arguments = {
4626 "endpoint": self._serialize.url(
4627 "self._config.base_url", self._config.base_url, "str", skip_quote=True
4628 ),
4629 }
4630 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4632 return _request
4634 def extract_data(pipeline_response):
4635 deserialized = pipeline_response.http_response.json()
4636 list_of_elem = _deserialize(
4637 List[_models.LinkableEnvironmentResponse],
4638 deserialized.get("value", []),
4639 )
4640 if cls:
4641 list_of_elem = cls(list_of_elem) # type: ignore
4642 return deserialized.get("nextLink") or None, iter(list_of_elem)
4644 def get_next(next_link=None):
4645 _request = prepare_request(next_link)
4647 _stream = False
4648 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4649 _request, stream=_stream, **kwargs
4650 )
4651 response = pipeline_response.http_response
4653 if response.status_code not in [200]:
4654 map_error(status_code=response.status_code, response=response, error_map=error_map)
4655 error = _failsafe_deserialize(
4656 _models.ErrorResponse,
4657 response,
4658 )
4659 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4661 return pipeline_response
4663 return ItemPaged(get_next, extract_data)
4665 @overload
4666 def get_all_connected_resources_count(
4667 self,
4668 request: _models.MarketplaceSubscriptionIdRequest,
4669 *,
4670 content_type: str = "application/json",
4671 **kwargs: Any
4672 ) -> _models.ConnectedResourcesCountResponse:
4673 """Get the total number of connected resources for the given marketplace subscription Id.
4675 :param request: The request body. Required.
4676 :type request: ~azure.mgmt.dynatrace.models.MarketplaceSubscriptionIdRequest
4677 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4678 Default value is "application/json".
4679 :paramtype content_type: str
4680 :return: ConnectedResourcesCountResponse. The ConnectedResourcesCountResponse is compatible
4681 with MutableMapping
4682 :rtype: ~azure.mgmt.dynatrace.models.ConnectedResourcesCountResponse
4683 :raises ~azure.core.exceptions.HttpResponseError:
4684 """
4686 @overload
4687 def get_all_connected_resources_count(
4688 self, request: _types.MarketplaceSubscriptionIdRequest, *, content_type: str = "application/json", **kwargs: Any
4689 ) -> _models.ConnectedResourcesCountResponse:
4690 """Get the total number of connected resources for the given marketplace subscription Id.
4692 :param request: The request body. Required.
4693 :type request: ~azure.mgmt.dynatrace.types.MarketplaceSubscriptionIdRequest
4694 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4695 Default value is "application/json".
4696 :paramtype content_type: str
4697 :return: ConnectedResourcesCountResponse. The ConnectedResourcesCountResponse is compatible
4698 with MutableMapping
4699 :rtype: ~azure.mgmt.dynatrace.models.ConnectedResourcesCountResponse
4700 :raises ~azure.core.exceptions.HttpResponseError:
4701 """
4703 @overload
4704 def get_all_connected_resources_count(
4705 self, request: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
4706 ) -> _models.ConnectedResourcesCountResponse:
4707 """Get the total number of connected resources for the given marketplace subscription Id.
4709 :param request: The request body. Required.
4710 :type request: IO[bytes]
4711 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
4712 Default value is "application/json".
4713 :paramtype content_type: str
4714 :return: ConnectedResourcesCountResponse. The ConnectedResourcesCountResponse is compatible
4715 with MutableMapping
4716 :rtype: ~azure.mgmt.dynatrace.models.ConnectedResourcesCountResponse
4717 :raises ~azure.core.exceptions.HttpResponseError:
4718 """
4720 @distributed_trace
4721 def get_all_connected_resources_count(
4722 self,
4723 request: Union[_models.MarketplaceSubscriptionIdRequest, _types.MarketplaceSubscriptionIdRequest, IO[bytes]],
4724 **kwargs: Any
4725 ) -> _models.ConnectedResourcesCountResponse:
4726 """Get the total number of connected resources for the given marketplace subscription Id.
4728 :param request: The request body. Is either a MarketplaceSubscriptionIdRequest type or a
4729 IO[bytes] type. Required.
4730 :type request: ~azure.mgmt.dynatrace.models.MarketplaceSubscriptionIdRequest or
4731 ~azure.mgmt.dynatrace.types.MarketplaceSubscriptionIdRequest or IO[bytes]
4732 :return: ConnectedResourcesCountResponse. The ConnectedResourcesCountResponse is compatible
4733 with MutableMapping
4734 :rtype: ~azure.mgmt.dynatrace.models.ConnectedResourcesCountResponse
4735 :raises ~azure.core.exceptions.HttpResponseError:
4736 """
4737 error_map: MutableMapping = {
4738 401: ClientAuthenticationError,
4739 404: ResourceNotFoundError,
4740 409: ResourceExistsError,
4741 304: ResourceNotModifiedError,
4742 }
4743 error_map.update(kwargs.pop("error_map", {}) or {})
4745 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4746 _params = kwargs.pop("params", {}) or {}
4748 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4749 cls: ClsType[_models.ConnectedResourcesCountResponse] = kwargs.pop("cls", None)
4751 content_type = content_type or "application/json"
4752 _content = None
4753 if isinstance(request, (IOBase, bytes)):
4754 _content = request
4755 else:
4756 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
4758 _request = build_monitors_get_all_connected_resources_count_request(
4759 subscription_id=self._config.subscription_id,
4760 content_type=content_type,
4761 api_version=self._config.api_version,
4762 content=_content,
4763 headers=_headers,
4764 params=_params,
4765 )
4766 path_format_arguments = {
4767 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
4768 }
4769 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4771 _decompress = kwargs.pop("decompress", True)
4772 _stream = kwargs.pop("stream", False)
4773 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4774 _request, stream=_stream, **kwargs
4775 )
4777 response = pipeline_response.http_response
4779 if response.status_code not in [200]:
4780 if _stream:
4781 try:
4782 response.read() # Load the body in memory and close the socket
4783 except (StreamConsumedError, StreamClosedError):
4784 pass
4785 map_error(status_code=response.status_code, response=response, error_map=error_map)
4786 error = _failsafe_deserialize(
4787 _models.ErrorResponse,
4788 response,
4789 )
4790 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4792 if _stream:
4793 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
4794 else:
4795 deserialized = _deserialize(_models.ConnectedResourcesCountResponse, response.json())
4797 if cls:
4798 return cls(pipeline_response, deserialized, {}) # type: ignore
4800 return deserialized # type: ignore
4802 @overload
4803 def get_marketplace_saa_s_resource_details(
4804 self,
4805 request: _models.MarketplaceSaaSResourceDetailsRequest,
4806 *,
4807 content_type: str = "application/json",
4808 **kwargs: Any
4809 ) -> _models.MarketplaceSaaSResourceDetailsResponse:
4810 """Get Marketplace SaaS resource details.
4812 :param request: The request body. Required.
4813 :type request: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsRequest
4814 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4815 Default value is "application/json".
4816 :paramtype content_type: str
4817 :return: MarketplaceSaaSResourceDetailsResponse. The MarketplaceSaaSResourceDetailsResponse is
4818 compatible with MutableMapping
4819 :rtype: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsResponse
4820 :raises ~azure.core.exceptions.HttpResponseError:
4821 """
4823 @overload
4824 def get_marketplace_saa_s_resource_details(
4825 self,
4826 request: _types.MarketplaceSaaSResourceDetailsRequest,
4827 *,
4828 content_type: str = "application/json",
4829 **kwargs: Any
4830 ) -> _models.MarketplaceSaaSResourceDetailsResponse:
4831 """Get Marketplace SaaS resource details.
4833 :param request: The request body. Required.
4834 :type request: ~azure.mgmt.dynatrace.types.MarketplaceSaaSResourceDetailsRequest
4835 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
4836 Default value is "application/json".
4837 :paramtype content_type: str
4838 :return: MarketplaceSaaSResourceDetailsResponse. The MarketplaceSaaSResourceDetailsResponse is
4839 compatible with MutableMapping
4840 :rtype: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsResponse
4841 :raises ~azure.core.exceptions.HttpResponseError:
4842 """
4844 @overload
4845 def get_marketplace_saa_s_resource_details(
4846 self, request: IO[bytes], *, content_type: str = "application/json", **kwargs: Any
4847 ) -> _models.MarketplaceSaaSResourceDetailsResponse:
4848 """Get Marketplace SaaS resource details.
4850 :param request: The request body. Required.
4851 :type request: IO[bytes]
4852 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
4853 Default value is "application/json".
4854 :paramtype content_type: str
4855 :return: MarketplaceSaaSResourceDetailsResponse. The MarketplaceSaaSResourceDetailsResponse is
4856 compatible with MutableMapping
4857 :rtype: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsResponse
4858 :raises ~azure.core.exceptions.HttpResponseError:
4859 """
4861 @distributed_trace
4862 def get_marketplace_saa_s_resource_details(
4863 self,
4864 request: Union[
4865 _models.MarketplaceSaaSResourceDetailsRequest, _types.MarketplaceSaaSResourceDetailsRequest, IO[bytes]
4866 ],
4867 **kwargs: Any
4868 ) -> _models.MarketplaceSaaSResourceDetailsResponse:
4869 """Get Marketplace SaaS resource details.
4871 :param request: The request body. Is either a MarketplaceSaaSResourceDetailsRequest type or a
4872 IO[bytes] type. Required.
4873 :type request: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsRequest or
4874 ~azure.mgmt.dynatrace.types.MarketplaceSaaSResourceDetailsRequest or IO[bytes]
4875 :return: MarketplaceSaaSResourceDetailsResponse. The MarketplaceSaaSResourceDetailsResponse is
4876 compatible with MutableMapping
4877 :rtype: ~azure.mgmt.dynatrace.models.MarketplaceSaaSResourceDetailsResponse
4878 :raises ~azure.core.exceptions.HttpResponseError:
4879 """
4880 error_map: MutableMapping = {
4881 401: ClientAuthenticationError,
4882 404: ResourceNotFoundError,
4883 409: ResourceExistsError,
4884 304: ResourceNotModifiedError,
4885 }
4886 error_map.update(kwargs.pop("error_map", {}) or {})
4888 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
4889 _params = kwargs.pop("params", {}) or {}
4891 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
4892 cls: ClsType[_models.MarketplaceSaaSResourceDetailsResponse] = kwargs.pop("cls", None)
4894 content_type = content_type or "application/json"
4895 _content = None
4896 if isinstance(request, (IOBase, bytes)):
4897 _content = request
4898 else:
4899 _content = json.dumps(request, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
4901 _request = build_monitors_get_marketplace_saa_s_resource_details_request(
4902 subscription_id=self._config.subscription_id,
4903 content_type=content_type,
4904 api_version=self._config.api_version,
4905 content=_content,
4906 headers=_headers,
4907 params=_params,
4908 )
4909 path_format_arguments = {
4910 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
4911 }
4912 _request.url = self._client.format_url(_request.url, **path_format_arguments)
4914 _decompress = kwargs.pop("decompress", True)
4915 _stream = kwargs.pop("stream", False)
4916 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
4917 _request, stream=_stream, **kwargs
4918 )
4920 response = pipeline_response.http_response
4922 if response.status_code not in [200]:
4923 if _stream:
4924 try:
4925 response.read() # Load the body in memory and close the socket
4926 except (StreamConsumedError, StreamClosedError):
4927 pass
4928 map_error(status_code=response.status_code, response=response, error_map=error_map)
4929 error = _failsafe_deserialize(
4930 _models.ErrorResponse,
4931 response,
4932 )
4933 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
4935 if _stream:
4936 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
4937 else:
4938 deserialized = _deserialize(_models.MarketplaceSaaSResourceDetailsResponse, response.json())
4940 if cls:
4941 return cls(pipeline_response, deserialized, {}) # type: ignore
4943 return deserialized # type: ignore
4946class SingleSignOnOperations:
4947 """
4948 .. warning::
4949 **DO NOT** instantiate this class directly.
4951 Instead, you should access the following operations through
4952 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
4953 :attr:`single_sign_on` attribute.
4954 """
4956 def __init__(self, *args, **kwargs) -> None:
4957 input_args = list(args)
4958 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
4959 self._config: DynatraceObservabilityMgmtClientConfiguration = (
4960 input_args.pop(0) if input_args else kwargs.pop("config")
4961 )
4962 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
4963 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
4965 @distributed_trace
4966 def get(
4967 self, resource_group_name: str, monitor_name: str, configuration_name: str, **kwargs: Any
4968 ) -> _models.DynatraceSingleSignOnResource:
4969 """Get a DynatraceSingleSignOnResource.
4971 :param resource_group_name: The name of the resource group. The name is case insensitive.
4972 Required.
4973 :type resource_group_name: str
4974 :param monitor_name: Monitor resource name. Required.
4975 :type monitor_name: str
4976 :param configuration_name: Single Sign On Configuration Name. Required.
4977 :type configuration_name: str
4978 :return: DynatraceSingleSignOnResource. The DynatraceSingleSignOnResource is compatible with
4979 MutableMapping
4980 :rtype: ~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource
4981 :raises ~azure.core.exceptions.HttpResponseError:
4982 """
4983 error_map: MutableMapping = {
4984 401: ClientAuthenticationError,
4985 404: ResourceNotFoundError,
4986 409: ResourceExistsError,
4987 304: ResourceNotModifiedError,
4988 }
4989 error_map.update(kwargs.pop("error_map", {}) or {})
4991 _headers = kwargs.pop("headers", {}) or {}
4992 _params = kwargs.pop("params", {}) or {}
4994 cls: ClsType[_models.DynatraceSingleSignOnResource] = kwargs.pop("cls", None)
4996 _request = build_single_sign_on_get_request(
4997 resource_group_name=resource_group_name,
4998 monitor_name=monitor_name,
4999 configuration_name=configuration_name,
5000 subscription_id=self._config.subscription_id,
5001 api_version=self._config.api_version,
5002 headers=_headers,
5003 params=_params,
5004 )
5005 path_format_arguments = {
5006 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
5007 }
5008 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5010 _decompress = kwargs.pop("decompress", True)
5011 _stream = kwargs.pop("stream", False)
5012 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
5013 _request, stream=_stream, **kwargs
5014 )
5016 response = pipeline_response.http_response
5018 if response.status_code not in [200]:
5019 if _stream:
5020 try:
5021 response.read() # Load the body in memory and close the socket
5022 except (StreamConsumedError, StreamClosedError):
5023 pass
5024 map_error(status_code=response.status_code, response=response, error_map=error_map)
5025 error = _failsafe_deserialize(
5026 _models.ErrorResponse,
5027 response,
5028 )
5029 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
5031 if _stream:
5032 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
5033 else:
5034 deserialized = _deserialize(_models.DynatraceSingleSignOnResource, response.json())
5036 if cls:
5037 return cls(pipeline_response, deserialized, {}) # type: ignore
5039 return deserialized # type: ignore
5041 def _create_or_update_initial(
5042 self,
5043 resource_group_name: str,
5044 monitor_name: str,
5045 configuration_name: str,
5046 resource: Union[_models.DynatraceSingleSignOnResource, _types.DynatraceSingleSignOnResource, IO[bytes]],
5047 **kwargs: Any
5048 ) -> Iterator[bytes]:
5049 error_map: MutableMapping = {
5050 401: ClientAuthenticationError,
5051 404: ResourceNotFoundError,
5052 409: ResourceExistsError,
5053 304: ResourceNotModifiedError,
5054 }
5055 error_map.update(kwargs.pop("error_map", {}) or {})
5057 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
5058 _params = kwargs.pop("params", {}) or {}
5060 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
5061 cls: ClsType[Iterator[bytes]] = kwargs.pop("cls", None)
5063 content_type = content_type or "application/json"
5064 _content = None
5065 if isinstance(resource, (IOBase, bytes)):
5066 _content = resource
5067 else:
5068 _content = json.dumps(resource, cls=SdkJSONEncoder, exclude_readonly=True) # type: ignore
5070 _request = build_single_sign_on_create_or_update_request(
5071 resource_group_name=resource_group_name,
5072 monitor_name=monitor_name,
5073 configuration_name=configuration_name,
5074 subscription_id=self._config.subscription_id,
5075 content_type=content_type,
5076 api_version=self._config.api_version,
5077 content=_content,
5078 headers=_headers,
5079 params=_params,
5080 )
5081 path_format_arguments = {
5082 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
5083 }
5084 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5086 _decompress = kwargs.pop("decompress", True)
5087 _stream = True
5088 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
5089 _request, stream=_stream, **kwargs
5090 )
5092 response = pipeline_response.http_response
5094 if response.status_code not in [200, 201]:
5095 try:
5096 response.read() # Load the body in memory and close the socket
5097 except (StreamConsumedError, StreamClosedError):
5098 pass
5099 map_error(status_code=response.status_code, response=response, error_map=error_map)
5100 error = _failsafe_deserialize(
5101 _models.ErrorResponse,
5102 response,
5103 )
5104 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
5106 response_headers = {}
5107 if response.status_code == 201:
5108 response_headers["Azure-AsyncOperation"] = self._deserialize(
5109 "str", response.headers.get("Azure-AsyncOperation")
5110 )
5111 response_headers["Retry-After"] = self._deserialize("int", response.headers.get("Retry-After"))
5113 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
5115 if cls:
5116 return cls(pipeline_response, deserialized, response_headers) # type: ignore
5118 return deserialized # type: ignore
5120 @overload
5121 def begin_create_or_update(
5122 self,
5123 resource_group_name: str,
5124 monitor_name: str,
5125 configuration_name: str,
5126 resource: _models.DynatraceSingleSignOnResource,
5127 *,
5128 content_type: str = "application/json",
5129 **kwargs: Any
5130 ) -> LROPoller[_models.DynatraceSingleSignOnResource]:
5131 """Create a DynatraceSingleSignOnResource.
5133 :param resource_group_name: The name of the resource group. The name is case insensitive.
5134 Required.
5135 :type resource_group_name: str
5136 :param monitor_name: Monitor resource name. Required.
5137 :type monitor_name: str
5138 :param configuration_name: Single Sign On Configuration Name. Required.
5139 :type configuration_name: str
5140 :param resource: Resource create parameters. Required.
5141 :type resource: ~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource
5142 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
5143 Default value is "application/json".
5144 :paramtype content_type: str
5145 :return: An instance of LROPoller that returns DynatraceSingleSignOnResource. The
5146 DynatraceSingleSignOnResource is compatible with MutableMapping
5147 :rtype:
5148 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource]
5149 :raises ~azure.core.exceptions.HttpResponseError:
5150 """
5152 @overload
5153 def begin_create_or_update(
5154 self,
5155 resource_group_name: str,
5156 monitor_name: str,
5157 configuration_name: str,
5158 resource: _types.DynatraceSingleSignOnResource,
5159 *,
5160 content_type: str = "application/json",
5161 **kwargs: Any
5162 ) -> LROPoller[_models.DynatraceSingleSignOnResource]:
5163 """Create a DynatraceSingleSignOnResource.
5165 :param resource_group_name: The name of the resource group. The name is case insensitive.
5166 Required.
5167 :type resource_group_name: str
5168 :param monitor_name: Monitor resource name. Required.
5169 :type monitor_name: str
5170 :param configuration_name: Single Sign On Configuration Name. Required.
5171 :type configuration_name: str
5172 :param resource: Resource create parameters. Required.
5173 :type resource: ~azure.mgmt.dynatrace.types.DynatraceSingleSignOnResource
5174 :keyword content_type: Body Parameter content-type. Content type parameter for JSON body.
5175 Default value is "application/json".
5176 :paramtype content_type: str
5177 :return: An instance of LROPoller that returns DynatraceSingleSignOnResource. The
5178 DynatraceSingleSignOnResource is compatible with MutableMapping
5179 :rtype:
5180 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource]
5181 :raises ~azure.core.exceptions.HttpResponseError:
5182 """
5184 @overload
5185 def begin_create_or_update(
5186 self,
5187 resource_group_name: str,
5188 monitor_name: str,
5189 configuration_name: str,
5190 resource: IO[bytes],
5191 *,
5192 content_type: str = "application/json",
5193 **kwargs: Any
5194 ) -> LROPoller[_models.DynatraceSingleSignOnResource]:
5195 """Create a DynatraceSingleSignOnResource.
5197 :param resource_group_name: The name of the resource group. The name is case insensitive.
5198 Required.
5199 :type resource_group_name: str
5200 :param monitor_name: Monitor resource name. Required.
5201 :type monitor_name: str
5202 :param configuration_name: Single Sign On Configuration Name. Required.
5203 :type configuration_name: str
5204 :param resource: Resource create parameters. Required.
5205 :type resource: IO[bytes]
5206 :keyword content_type: Body Parameter content-type. Content type parameter for binary body.
5207 Default value is "application/json".
5208 :paramtype content_type: str
5209 :return: An instance of LROPoller that returns DynatraceSingleSignOnResource. The
5210 DynatraceSingleSignOnResource is compatible with MutableMapping
5211 :rtype:
5212 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource]
5213 :raises ~azure.core.exceptions.HttpResponseError:
5214 """
5216 @distributed_trace
5217 def begin_create_or_update(
5218 self,
5219 resource_group_name: str,
5220 monitor_name: str,
5221 configuration_name: str,
5222 resource: Union[_models.DynatraceSingleSignOnResource, _types.DynatraceSingleSignOnResource, IO[bytes]],
5223 **kwargs: Any
5224 ) -> LROPoller[_models.DynatraceSingleSignOnResource]:
5225 """Create a DynatraceSingleSignOnResource.
5227 :param resource_group_name: The name of the resource group. The name is case insensitive.
5228 Required.
5229 :type resource_group_name: str
5230 :param monitor_name: Monitor resource name. Required.
5231 :type monitor_name: str
5232 :param configuration_name: Single Sign On Configuration Name. Required.
5233 :type configuration_name: str
5234 :param resource: Resource create parameters. Is either a DynatraceSingleSignOnResource type or
5235 a IO[bytes] type. Required.
5236 :type resource: ~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource or
5237 ~azure.mgmt.dynatrace.types.DynatraceSingleSignOnResource or IO[bytes]
5238 :return: An instance of LROPoller that returns DynatraceSingleSignOnResource. The
5239 DynatraceSingleSignOnResource is compatible with MutableMapping
5240 :rtype:
5241 ~azure.core.polling.LROPoller[~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource]
5242 :raises ~azure.core.exceptions.HttpResponseError:
5243 """
5244 _headers = case_insensitive_dict(kwargs.pop("headers", {}) or {})
5245 _params = kwargs.pop("params", {}) or {}
5247 content_type: Optional[str] = kwargs.pop("content_type", _headers.pop("Content-Type", None))
5248 cls: ClsType[_models.DynatraceSingleSignOnResource] = kwargs.pop("cls", None)
5249 polling: Union[bool, PollingMethod] = kwargs.pop("polling", True)
5250 lro_delay = kwargs.pop("polling_interval", self._config.polling_interval)
5251 cont_token: Optional[str] = kwargs.pop("continuation_token", None)
5252 if cont_token is None:
5253 raw_result = self._create_or_update_initial(
5254 resource_group_name=resource_group_name,
5255 monitor_name=monitor_name,
5256 configuration_name=configuration_name,
5257 resource=resource,
5258 content_type=content_type,
5259 cls=lambda x, y, z: x,
5260 headers=_headers,
5261 params=_params,
5262 **kwargs
5263 )
5264 raw_result.http_response.read() # type: ignore
5265 kwargs.pop("error_map", None)
5267 def get_long_running_output(pipeline_response):
5268 response = pipeline_response.http_response
5269 deserialized = _deserialize(_models.DynatraceSingleSignOnResource, response.json())
5270 if cls:
5271 return cls(pipeline_response, deserialized, {}) # type: ignore
5272 return deserialized
5274 path_format_arguments = {
5275 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
5276 }
5278 if polling is True:
5279 polling_method: PollingMethod = cast(
5280 PollingMethod, ARMPolling(lro_delay, path_format_arguments=path_format_arguments, **kwargs)
5281 )
5282 elif polling is False:
5283 polling_method = cast(PollingMethod, NoPolling())
5284 else:
5285 polling_method = polling
5286 if cont_token:
5287 return LROPoller[_models.DynatraceSingleSignOnResource].from_continuation_token(
5288 polling_method=polling_method,
5289 continuation_token=cont_token,
5290 client=self._client,
5291 deserialization_callback=get_long_running_output,
5292 )
5293 return LROPoller[_models.DynatraceSingleSignOnResource](
5294 self._client, raw_result, get_long_running_output, polling_method # type: ignore
5295 )
5297 @distributed_trace
5298 def list(
5299 self, resource_group_name: str, monitor_name: str, **kwargs: Any
5300 ) -> ItemPaged["_models.DynatraceSingleSignOnResource"]:
5301 """List all DynatraceSingleSignOnResource by monitorName.
5303 :param resource_group_name: The name of the resource group. The name is case insensitive.
5304 Required.
5305 :type resource_group_name: str
5306 :param monitor_name: Monitor resource name. Required.
5307 :type monitor_name: str
5308 :return: An iterator like instance of DynatraceSingleSignOnResource
5309 :rtype:
5310 ~azure.core.paging.ItemPaged[~azure.mgmt.dynatrace.models.DynatraceSingleSignOnResource]
5311 :raises ~azure.core.exceptions.HttpResponseError:
5312 """
5313 _headers = kwargs.pop("headers", {}) or {}
5314 _params = kwargs.pop("params", {}) or {}
5316 cls: ClsType[List[_models.DynatraceSingleSignOnResource]] = kwargs.pop("cls", None)
5318 error_map: MutableMapping = {
5319 401: ClientAuthenticationError,
5320 404: ResourceNotFoundError,
5321 409: ResourceExistsError,
5322 304: ResourceNotModifiedError,
5323 }
5324 error_map.update(kwargs.pop("error_map", {}) or {})
5326 def prepare_request(next_link=None):
5327 if not next_link:
5329 _request = build_single_sign_on_list_request(
5330 resource_group_name=resource_group_name,
5331 monitor_name=monitor_name,
5332 subscription_id=self._config.subscription_id,
5333 api_version=self._config.api_version,
5334 headers=_headers,
5335 params=_params,
5336 )
5337 path_format_arguments = {
5338 "endpoint": self._serialize.url(
5339 "self._config.base_url", self._config.base_url, "str", skip_quote=True
5340 ),
5341 }
5342 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5344 else:
5345 # make call to next link with the client's api-version
5346 _parsed_next_link = urllib.parse.urlparse(next_link)
5347 _next_request_params = case_insensitive_dict(
5348 {
5349 key: [urllib.parse.quote(v) for v in value]
5350 for key, value in urllib.parse.parse_qs(_parsed_next_link.query).items()
5351 }
5352 )
5353 _next_request_params["api-version"] = self._config.api_version
5354 _request = HttpRequest(
5355 "GET",
5356 urllib.parse.urljoin(next_link, _parsed_next_link.path),
5357 headers=_headers,
5358 params=_next_request_params,
5359 )
5360 path_format_arguments = {
5361 "endpoint": self._serialize.url(
5362 "self._config.base_url", self._config.base_url, "str", skip_quote=True
5363 ),
5364 }
5365 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5367 return _request
5369 def extract_data(pipeline_response):
5370 deserialized = pipeline_response.http_response.json()
5371 list_of_elem = _deserialize(
5372 List[_models.DynatraceSingleSignOnResource],
5373 deserialized.get("value", []),
5374 )
5375 if cls:
5376 list_of_elem = cls(list_of_elem) # type: ignore
5377 return deserialized.get("nextLink") or None, iter(list_of_elem)
5379 def get_next(next_link=None):
5380 _request = prepare_request(next_link)
5382 _stream = False
5383 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
5384 _request, stream=_stream, **kwargs
5385 )
5386 response = pipeline_response.http_response
5388 if response.status_code not in [200]:
5389 map_error(status_code=response.status_code, response=response, error_map=error_map)
5390 error = _failsafe_deserialize(
5391 _models.ErrorResponse,
5392 response,
5393 )
5394 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
5396 return pipeline_response
5398 return ItemPaged(get_next, extract_data)
5401class CreationSupportedOperations:
5402 """
5403 .. warning::
5404 **DO NOT** instantiate this class directly.
5406 Instead, you should access the following operations through
5407 :class:`~azure.mgmt.dynatrace.DynatraceObservabilityMgmtClient`'s
5408 :attr:`creation_supported` attribute.
5409 """
5411 def __init__(self, *args, **kwargs) -> None:
5412 input_args = list(args)
5413 self._client: PipelineClient = input_args.pop(0) if input_args else kwargs.pop("client")
5414 self._config: DynatraceObservabilityMgmtClientConfiguration = (
5415 input_args.pop(0) if input_args else kwargs.pop("config")
5416 )
5417 self._serialize: Serializer = input_args.pop(0) if input_args else kwargs.pop("serializer")
5418 self._deserialize: Deserializer = input_args.pop(0) if input_args else kwargs.pop("deserializer")
5420 @distributed_trace
5421 def list(self, dynatrace_environment_id: str, **kwargs: Any) -> _models.CreateResourceSupportedResponse:
5422 """Informs if the current subscription is being already monitored for selected Dynatrace
5423 environment.
5425 Informs if the current subscription is being already monitored for selected Dynatrace
5426 environment.
5428 :param dynatrace_environment_id: Dynatrace Environment Id. Required.
5429 :type dynatrace_environment_id: str
5430 :return: CreateResourceSupportedResponse. The CreateResourceSupportedResponse is compatible
5431 with MutableMapping
5432 :rtype: ~azure.mgmt.dynatrace.models.CreateResourceSupportedResponse
5433 :raises ~azure.core.exceptions.HttpResponseError:
5434 """
5435 error_map: MutableMapping = {
5436 401: ClientAuthenticationError,
5437 404: ResourceNotFoundError,
5438 409: ResourceExistsError,
5439 304: ResourceNotModifiedError,
5440 }
5441 error_map.update(kwargs.pop("error_map", {}) or {})
5443 _headers = kwargs.pop("headers", {}) or {}
5444 _params = kwargs.pop("params", {}) or {}
5446 cls: ClsType[_models.CreateResourceSupportedResponse] = kwargs.pop("cls", None)
5448 _request = build_creation_supported_list_request(
5449 dynatrace_environment_id=dynatrace_environment_id,
5450 subscription_id=self._config.subscription_id,
5451 api_version=self._config.api_version,
5452 headers=_headers,
5453 params=_params,
5454 )
5455 path_format_arguments = {
5456 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
5457 }
5458 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5460 _decompress = kwargs.pop("decompress", True)
5461 _stream = kwargs.pop("stream", False)
5462 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
5463 _request, stream=_stream, **kwargs
5464 )
5466 response = pipeline_response.http_response
5468 if response.status_code not in [200]:
5469 if _stream:
5470 try:
5471 response.read() # Load the body in memory and close the socket
5472 except (StreamConsumedError, StreamClosedError):
5473 pass
5474 map_error(status_code=response.status_code, response=response, error_map=error_map)
5475 error = _failsafe_deserialize(
5476 _models.ErrorResponse,
5477 response,
5478 )
5479 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
5481 if _stream:
5482 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
5483 else:
5484 deserialized = _deserialize(_models.CreateResourceSupportedResponse, response.json())
5486 if cls:
5487 return cls(pipeline_response, deserialized, {}) # type: ignore
5489 return deserialized # type: ignore
5491 @distributed_trace
5492 def get(self, dynatrace_environment_id: str, **kwargs: Any) -> _models.CreateResourceSupportedResponse:
5493 """Informs if the current subscription is being already monitored for selected Dynatrace
5494 environment.
5496 Informs if the current subscription is being already monitored for selected Dynatrace
5497 environment.
5499 :param dynatrace_environment_id: Dynatrace Environment Id. Required.
5500 :type dynatrace_environment_id: str
5501 :return: CreateResourceSupportedResponse. The CreateResourceSupportedResponse is compatible
5502 with MutableMapping
5503 :rtype: ~azure.mgmt.dynatrace.models.CreateResourceSupportedResponse
5504 :raises ~azure.core.exceptions.HttpResponseError:
5505 """
5506 error_map: MutableMapping = {
5507 401: ClientAuthenticationError,
5508 404: ResourceNotFoundError,
5509 409: ResourceExistsError,
5510 304: ResourceNotModifiedError,
5511 }
5512 error_map.update(kwargs.pop("error_map", {}) or {})
5514 _headers = kwargs.pop("headers", {}) or {}
5515 _params = kwargs.pop("params", {}) or {}
5517 cls: ClsType[_models.CreateResourceSupportedResponse] = kwargs.pop("cls", None)
5519 _request = build_creation_supported_get_request(
5520 dynatrace_environment_id=dynatrace_environment_id,
5521 subscription_id=self._config.subscription_id,
5522 api_version=self._config.api_version,
5523 headers=_headers,
5524 params=_params,
5525 )
5526 path_format_arguments = {
5527 "endpoint": self._serialize.url("self._config.base_url", self._config.base_url, "str", skip_quote=True),
5528 }
5529 _request.url = self._client.format_url(_request.url, **path_format_arguments)
5531 _decompress = kwargs.pop("decompress", True)
5532 _stream = kwargs.pop("stream", False)
5533 pipeline_response: PipelineResponse = self._client._pipeline.run( # pylint: disable=protected-access
5534 _request, stream=_stream, **kwargs
5535 )
5537 response = pipeline_response.http_response
5539 if response.status_code not in [200]:
5540 if _stream:
5541 try:
5542 response.read() # Load the body in memory and close the socket
5543 except (StreamConsumedError, StreamClosedError):
5544 pass
5545 map_error(status_code=response.status_code, response=response, error_map=error_map)
5546 error = _failsafe_deserialize(
5547 _models.ErrorResponse,
5548 response,
5549 )
5550 raise HttpResponseError(response=response, model=error, error_format=ARMErrorFormat)
5552 if _stream:
5553 deserialized = response.iter_bytes() if _decompress else response.iter_raw()
5554 else:
5555 deserialized = _deserialize(_models.CreateResourceSupportedResponse, response.json())
5557 if cls:
5558 return cls(pipeline_response, deserialized, {}) # type: ignore
5560 return deserialized # type: ignore