def __init__(
self,
hass,
ip_address,
port,
topic,
security_protocol,
username,
password,
):
"""Initialize."""
self._encoder = DateTimeJSONEncoder()
self._hass = hass
ssl_context = ssl_util.client_context()
self._producer = AIOKafkaProducer(
loop=hass.loop,
bootstrap_servers=f"{ip_address}:{port}",
compression_type="gzip",
security_protocol=security_protocol,
ssl_context=ssl_context,
sasl_mechanism="PLAIN",
sasl_plain_username=username,
sasl_plain_password=password,
)
self._topic = topic
def _async_get_connector(hass: HomeAssistantType,
verify_ssl: bool = True) -> aiohttp.BaseConnector:
"""Return the connector pool for aiohttp.
This method must be run in the event loop.
"""
key = DATA_CONNECTOR if verify_ssl else DATA_CONNECTOR_NOTVERIFY
if key in hass.data:
return cast(aiohttp.BaseConnector, hass.data[key])
if verify_ssl:
ssl_context: Union[bool, SSLContext] = ssl_util.client_context()
else:
ssl_context = False
connector = aiohttp.TCPConnector(enable_cleanup_closed=True,
ssl=ssl_context)
hass.data[key] = connector
async def _async_close_connector(event: Event) -> None:
"""Close connector pool."""
await connector.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE,
_async_close_connector)
return connector
def _async_get_connector(hass, verify_ssl=True):
"""Return the connector pool for aiohttp.
This method must be run in the event loop.
"""
key = DATA_CONNECTOR if verify_ssl else DATA_CONNECTOR_NOTVERIFY
if key in hass.data:
return hass.data[key]
if verify_ssl:
ssl_context = ssl_util.client_context()
else:
ssl_context = False
connector = aiohttp.TCPConnector(loop=hass.loop, ssl=ssl_context)
hass.data[key] = connector
async def _async_close_connector(event):
"""Close connector pool."""
await connector.close()
hass.bus.async_listen_once(
EVENT_HOMEASSISTANT_CLOSE, _async_close_connector)
return connector
def _async_get_connector(hass, verify_ssl=True):
"""Return the connector pool for aiohttp.
This method must be run in the event loop.
"""
key = DATA_CONNECTOR if verify_ssl else DATA_CONNECTOR_NOTVERIFY
if key in hass.data:
return hass.data[key]
if verify_ssl:
ssl_context = ssl_util.client_context()
else:
ssl_context = False
connector = aiohttp.TCPConnector(loop=hass.loop, ssl=ssl_context)
hass.data[key] = connector
@callback
def _async_close_connector(event):
"""Close connector pool."""
connector.close()
hass.bus.async_listen_once(EVENT_HOMEASSISTANT_CLOSE,
_async_close_connector)
return connector
async def async_step_user(self, user_input=None):
"""Handle a flow initiated by the user."""
errors = {}
if user_input is None:
return await self._show_setup_form()
# check for existing
entries = self._async_current_entries()
for entry in entries:
if entry.data[CONF_URL] == user_input[CONF_URL]:
errors[CONF_URL] = "server_exists"
return await self._show_setup_form(user_input, errors)
elif entry.unique_id == user_input[CONF_URL]:
errors[CONF_NAME] = "name_exists"
return await self._show_setup_form(user_input, errors)
# attempt to connect
validate_cert = not user_input[CONF_SKIP_VERIFICATION]
try:
context = None
if validate_cert:
context = ssl.client_context()
version = await Client.test_connection(user_input[CONF_URL],
validate_cert=validate_cert,
ssl_options=context)
if version is None:
errors[CONF_URL] = f"unkonwn_version"
except ConnectionRefusedError:
errors[CONF_URL] = "connection_refused"
except HTTPTimeoutError:
errors[CONF_URL] = "connection_timeout"
except HTTPClientError as error:
# connection_error_301
# connection_error_302
# connection_error_404
errors[CONF_URL] = f"connection_error_{error.code}"
except SSLCertVerificationError:
errors[CONF_URL] = "ssl_verification"
except Exception:
errors[CONF_URL] = "unknown_error"
if bool(errors):
return await self._show_setup_form(user_input, errors)
await self.async_set_unique_id(user_input[CONF_URL])
return self.async_create_entry(
title=user_input[CONF_NAME],
data={
CONF_URL: user_input[CONF_URL],
CONF_VERIFY_SSL: validate_cert,
},
)
def connect(self):
"""Login and setup the connection."""
ssl_context = client_context() if self._verify_ssl else None
try:
self.connection = imaplib.IMAP4_SSL(
self._server, self._port, ssl_context=ssl_context
)
self.connection.login(self._user, self._password)
return True
except imaplib.IMAP4.error:
_LOGGER.error("Failed to login to %s", self._server)
return False
async def async_added_to_hass(self):
context = None
if self._validate_cert:
context = ssl.client_context()
await self._client.connect(
validate_cert=self._validate_cert, ssl_options=context
)
await self.async_refresh_playlists()
state = await self._client.playback.get_state()
await self._playback_state_changed(None, state)
tl_track = await self._client.playback.get_current_tl_track()
if tl_track:
await self._track_playback_started(tl_track)
def connect(self):
"""Connect/authenticate to SMTP Server."""
ssl_context = client_context() if self._verify_ssl else None
if self.encryption == "tls":
mail = smtplib.SMTP_SSL(
self._server,
self._port,
timeout=self._timeout,
context=ssl_context,
)
else:
mail = smtplib.SMTP(self._server,
self._port,
timeout=self._timeout)
mail.set_debuglevel(self.debug)
mail.ehlo_or_helo_if_needed()
if self.encryption == "starttls":
mail.starttls(context=ssl_context)
mail.ehlo()
if self.username and self.password:
mail.login(self.username, self.password)
return mail
def __init__(self, url, apiKey, session):
self._url = url
self._api_key = apiKey
self._session = session
self._context = ssl.client_context()
