Debian Codegraph @

azure-kusto-data/azure/kusto/data/aio/client.py

raw
1 import io
2 from datetime import timedelta
3 from typing import Optional, Union
4
5 from azure.core.tracing import SpanKind
6 from azure.core.tracing.decorator_async import distributed_trace_async
7
8 from .response import KustoStreamingResponseDataSet
9 from .._decorators import aio_documented_by, documented_by
10 from .._telemetry import MonitoredActivity, Span
11 from ..aio.streaming_response import JsonTokenReader, StreamingDataSetEnumerator
12 from ..client import KustoClient as KustoClientSync
13 from ..client_base import ExecuteRequestParams, _KustoClientBase
14 from ..client_request_properties import ClientRequestProperties
15 from ..data_format import DataFormat
16 from ..exceptions import KustoAioSyntaxError, KustoClosedError, KustoNetworkError
17 from ..kcsb import KustoConnectionStringBuilder
18 from ..response import KustoResponseDataSet
19
20 try:
21 from aiohttp import ClientResponse, ClientSession
22 except ImportError:
23 raise KustoAioSyntaxError()
24
25
26 @documented_by(KustoClientSync)
27 class KustoClient(_KustoClientBase):
28 @documented_by(KustoClientSync.__init__)
29 def __init__(self, kcsb: Union[KustoConnectionStringBuilder, str]):
30 super().__init__(kcsb, True)
31
32 self._session = ClientSession()
33
34 async def __aenter__(self) -> "KustoClient":
35 return self
36
37 async def close(self):
38 if not self._is_closed:
39 await self._session.close()
40 if self._aad_helper:
41 await self._aad_helper.close_async()
42 super().close()
43
44 async def __aexit__(self, exc_type, exc_val, exc_tb):
45 await self.close()
46
47 @aio_documented_by(KustoClientSync.execute)
48 async def execute(self, database: Optional[str], query: str, properties: ClientRequestProperties = None) -> KustoResponseDataSet:
49 query = query.strip()
50 if query.startswith("."):
51 return await self.execute_mgmt(database, query, properties)
52 return await self.execute_query(database, query, properties)
53
54 @distributed_trace_async(name_of_span="AioKustoClient.query_cmd", kind=SpanKind.CLIENT)
55 @aio_documented_by(KustoClientSync.execute_query)
56 async def execute_query(self, database: str, query: str, properties: ClientRequestProperties = None) -> KustoResponseDataSet:
57 database = self._get_database_or_default(database)
58 Span.set_query_attributes(self._kusto_cluster, database, properties)
59 request = ExecuteRequestParams._from_query(
60 query,
61 database,
62 properties,
63 self._request_headers,
64 self._query_default_timeout,
65 self._mgmt_default_timeout,
66 self._client_server_delta,
67 self.client_details,
68 )
69 return await self._execute(self._query_endpoint, request, properties)
70
71 @distributed_trace_async(name_of_span="AioKustoClient.control_cmd", kind=SpanKind.CLIENT)
72 @aio_documented_by(KustoClientSync.execute_mgmt)
73 async def execute_mgmt(self, database: str, query: str, properties: ClientRequestProperties = None) -> KustoResponseDataSet:
74 database = self._get_database_or_default(database)
75 Span.set_query_attributes(self._kusto_cluster, database, properties)
76 request = ExecuteRequestParams._from_query(
77 query,
78 database,
79 properties,
80 self._request_headers,
81 self._mgmt_default_timeout,
82 self._mgmt_default_timeout,
83 self._client_server_delta,
84 self.client_details,
85 )
86 return await self._execute(self._mgmt_endpoint, request, properties)
87
88 @distributed_trace_async(name_of_span="AioKustoClient.streaming_ingest", kind=SpanKind.CLIENT)
89 @aio_documented_by(KustoClientSync.execute_streaming_ingest)
90 async def execute_streaming_ingest(
91 self,
92 database: Optional[str],
93 table: str,
94 stream: Optional[io.IOBase],
95 blob_url: Optional[str],
96 stream_format: Union[DataFormat, str],
97 properties: ClientRequestProperties = None,
98 mapping_name: str = None,
99 ):
100 database = self._get_database_or_default(database)
101
102 stream_format = stream_format.kusto_value if isinstance(stream_format, DataFormat) else DataFormat[stream_format.upper()].kusto_value
103 endpoint = self._streaming_ingest_endpoint + database + "/" + table + "?streamFormat=" + stream_format
104 if mapping_name is not None:
105 endpoint = endpoint + "&mappingName=" + mapping_name
106
107 if blob_url:
108 endpoint += "&sourceKind=uri"
109 request = ExecuteRequestParams._from_blob_url(
110 blob_url,
111 properties,
112 self._request_headers,
113 self._streaming_ingest_default_timeout,
114 self._mgmt_default_timeout,
115 self._client_server_delta,
116 self.client_details,
117 )
118 elif stream:
119 request = ExecuteRequestParams._from_stream(
120 stream,
121 properties,
122 self._request_headers,
123 self._streaming_ingest_default_timeout,
124 self._mgmt_default_timeout,
125 self._client_server_delta,
126 self.client_details,
127 )
128 else:
129 raise Exception("execute_streaming_ingest is expecting either a stream or blob url")
130
131 Span.set_streaming_ingest_attributes(self._kusto_cluster, database, table, properties)
132 await self._execute(endpoint, request, properties)
133
134 @aio_documented_by(KustoClientSync._execute_streaming_query_parsed)
135 async def _execute_streaming_query_parsed(
136 self,
137 database: Optional[str],
138 query: str,
139 timeout: timedelta = _KustoClientBase._query_default_timeout,
140 properties: Optional[ClientRequestProperties] = None,
141 ) -> StreamingDataSetEnumerator:
142 request = ExecuteRequestParams._from_query(
143 query, database, properties, self._request_headers, timeout, self._mgmt_default_timeout, self._client_server_delta, self.client_details
144 )
145 response = await self._execute(self._query_endpoint, request, properties, stream_response=True)
146 return StreamingDataSetEnumerator(JsonTokenReader(response.content))
147
148 @distributed_trace_async(name_of_span="AioKustoClient.streaming_query", kind=SpanKind.CLIENT)
149 @aio_documented_by(KustoClientSync.execute_streaming_query)
150 async def execute_streaming_query(
151 self,
152 database: Optional[str],
153 query: str,
154 timeout: timedelta = _KustoClientBase._query_default_timeout,
155 properties: Optional[ClientRequestProperties] = None,
156 ) -> KustoStreamingResponseDataSet:
157 database = self._get_database_or_default(database)
158 Span.set_query_attributes(self._kusto_cluster, database, properties)
159
160 response = await self._execute_streaming_query_parsed(database, query, timeout, properties)
161 return KustoStreamingResponseDataSet(response)
162
163 @aio_documented_by(KustoClientSync._execute)
164 async def _execute(
165 self,
166 endpoint: str,
167 request: ExecuteRequestParams,
168 properties: Optional[ClientRequestProperties] = None,
169 stream_response: bool = False,
170 ) -> Union[KustoResponseDataSet, ClientResponse]:
171 """Executes given query against this client"""
172 if self._is_closed:
173 raise KustoClosedError()
174 self.validate_endpoint()
175
176 request_headers = request.request_headers
177 timeout = request.timeout
178 if self._aad_helper:
179 request_headers["Authorization"] = await self._aad_helper.acquire_authorization_header_async()
180
181 invoker = lambda: self._session.post(
182 endpoint,
183 headers=request_headers,
184 json=request.json_payload,
185 data=request.payload,
186 timeout=timeout.seconds,
187 proxy=self._proxy_url,
188 allow_redirects=False,
189 )
190
191 try:
192 response = await MonitoredActivity.invoke_async(
193 invoker, name_of_span="AioKustoClient.http_post", tracing_attributes=Span.create_http_attributes("POST", endpoint, request_headers)
194 )
195 except Exception as e:
196 raise KustoNetworkError(endpoint, None if properties is None else properties.client_request_id) from e
197
198 if stream_response:
199 try:
200 response.raise_for_status()
201 if 300 <= response.status < 400:
202 raise Exception("Unexpected redirection, got status code: " + str(response.status))
203 return response
204 except Exception as e:
205 try:
206 response_text = await response.text()
207 except Exception:
208 response_text = None
209 try:
210 response_json = await response.json()
211 except Exception:
212 response_json = None
213 raise self._handle_http_error(e, endpoint, request.payload, response, response.status, response_json, response_text)
214
215 async with response:
216 response_json = None
217 try:
218 if 300 <= response.status < 400:
219 raise Exception("Unexpected redirection, got status code: " + str(response.status))
220 response_json = await response.json()
221 response.raise_for_status()
222 except Exception as e:
223 try:
224 response_text = await response.text()
225 except Exception:
226 response_text = None
227 raise self._handle_http_error(e, endpoint, request.payload, response, response.status, response_json, response_text)
228 return MonitoredActivity.invoke(lambda: self._kusto_parse_by_endpoint(endpoint, response_json), name_of_span="AioKustoClient.processing_response")