Enable cert_expiry config entries

.coveragerc

@@ -93,6 +93,7 @@ omit =
     homeassistant/components/canary/camera.py
     homeassistant/components/cast/*
     homeassistant/components/cert_expiry/sensor.py
+    homeassistant/components/cert_expiry/helper.py
     homeassistant/components/channels/media_player.py
     homeassistant/components/cisco_ios/device_tracker.py
     homeassistant/components/cisco_mobility_express/device_tracker.py

CODEOWNERS

@@ -46,6 +46,7 @@ homeassistant/components/broadlink/* @danielhiversen
 homeassistant/components/brunt/* @eavanvalkenburg
 homeassistant/components/bt_smarthub/* @jxwolstenholme
 homeassistant/components/buienradar/* @mjj4791 @ties
+homeassistant/components/cert_expiry/* @cereal2nd
 homeassistant/components/cisco_ios/* @fbradyirl
 homeassistant/components/cisco_mobility_express/* @fbradyirl
 homeassistant/components/cisco_webex_teams/* @fbradyirl

homeassistant/components/cert_expiry/.translations/en.json

@@ -0,0 +1,24 @@
+{
+    "config": {
+        "abort": {
+            "host_port_exists": "This host and port combination is already configured"
+        },
+        "error": {
+            "certificate_fetch_failed": "Can not fetch certificate from this host and port combination",
+            "connection_timeout": "Timeout whemn connecting to this host",
+            "host_port_exists": "This host and port combination is already configured",
+            "resolve_failed": "This host can not be resolved"
+        },
+        "step": {
+            "user": {
+                "data": {
+                    "host": "The hostname of the certificate",
+                    "name": "The name of the certificate",
+                    "port": "The port of the certificate"
+                },
+                "title": "Define the certificate to test"
+            }
+        },
+        "title": "Certificate Expiry"
+    }
+}

homeassistant/components/cert_expiry/__init__.py

@@ -1 +1,25 @@
 """The cert_expiry component."""
+from homeassistant.config_entries import ConfigEntry
+from homeassistant.const import EVENT_HOMEASSISTANT_START
+from homeassistant.core import callback
+from homeassistant.helpers.typing import HomeAssistantType
+
+
+async def async_setup(hass, config):
+    """Platform setup, do nothing."""
+    return True
+
+
+async def async_setup_entry(hass: HomeAssistantType, entry: ConfigEntry):
+    """Load the saved entities."""
+
+    @callback
+    def async_start(_):
+        """Load the entry after the start event."""
+        hass.async_create_task(
+            hass.config_entries.async_forward_entry_setup(entry, "sensor")
+        )
+
+    hass.bus.async_listen_once(EVENT_HOMEASSISTANT_START, async_start)
+
+    return True

homeassistant/components/cert_expiry/config_flow.py

@@ -0,0 +1,98 @@
+"""Config flow for the Cert Expiry platform."""
+import socket
+import voluptuous as vol
+
+from homeassistant import config_entries
+from homeassistant.const import CONF_PORT, CONF_NAME, CONF_HOST
+from homeassistant.core import HomeAssistant, callback
+from homeassistant.util import slugify
+
+from .const import DOMAIN, DEFAULT_PORT, DEFAULT_NAME
+from .helper import get_cert
+
+
+@callback
+def certexpiry_entries(hass: HomeAssistant):
+    """Return the host,port tuples for the domain."""
+    return set(
+        (entry.data[CONF_HOST], entry.data[CONF_PORT])
+        for entry in hass.config_entries.async_entries(DOMAIN)
+    )
+
+
+class CertexpiryConfigFlow(config_entries.ConfigFlow, domain=DOMAIN):
+    """Handle a config flow."""
+
+    VERSION = 1
+    CONNECTION_CLASS = config_entries.CONN_CLASS_LOCAL_POLL
+
+    def __init__(self) -> None:
+        """Initialize the config flow."""
+        self._errors = {}
+
+    def _prt_in_configuration_exists(self, user_input) -> bool:
+        """Return True if host, port combination exists in configuration."""
+        host = user_input[CONF_HOST]
+        port = user_input.get(CONF_PORT, DEFAULT_PORT)
+        if (host, port) in certexpiry_entries(self.hass):
+            return True
+        return False
+
+    def _test_connection(self, user_input=None):
+        """Test connection to the server and try to get the certtificate."""
+        try:
+            get_cert(user_input[CONF_HOST], user_input.get(CONF_PORT, DEFAULT_PORT))
+            return True
+        except socket.gaierror:
+            self._errors[CONF_HOST] = "resolve_failed"
+        except socket.timeout:
+            self._errors[CONF_HOST] = "connection_timeout"
+        except OSError:
+            self._errors[CONF_HOST] = "certificate_fetch_failed"
+        return False
+
+    async def async_step_user(self, user_input=None):
+        """Step when user intializes a integration."""
+        self._errors = {}
+        if user_input is not None:
+            # set some defaults in case we need to return to the form
+            if self._prt_in_configuration_exists(user_input):
+                self._errors[CONF_HOST] = "host_port_exists"
+            else:
+                if self._test_connection(user_input):
+                    host = user_input[CONF_HOST]
+                    name = slugify(user_input.get(CONF_NAME, DEFAULT_NAME))
+                    prt = user_input.get(CONF_PORT, DEFAULT_PORT)
+                    return self.async_create_entry(
+                        title=name, data={CONF_HOST: host, CONF_PORT: prt}
+                    )
+        else:
+            user_input = {}
+            user_input[CONF_NAME] = DEFAULT_NAME
+            user_input[CONF_HOST] = ""
+            user_input[CONF_PORT] = DEFAULT_PORT
+
+        return self.async_show_form(
+            step_id="user",
+            data_schema=vol.Schema(
+                {
+                    vol.Required(
+                        CONF_NAME, default=user_input.get(CONF_NAME, DEFAULT_NAME)
+                    ): str,
+                    vol.Required(CONF_HOST, default=user_input[CONF_HOST]): str,
+                    vol.Required(
+                        CONF_PORT, default=user_input.get(CONF_PORT, DEFAULT_PORT)
+                    ): int,
+                }
+            ),
+            errors=self._errors,
+        )
+
+    async def async_step_import(self, user_input=None):
+        """Import a config entry.
+
+        Only host was required in the yaml file all other fields are optional
+        """
+        if self._prt_in_configuration_exists(user_input):
+            return self.async_abort(reason="host_port_exists")
+        return await self.async_step_user(user_input)

homeassistant/components/cert_expiry/const.py

@@ -0,0 +1,6 @@
+"""Const for Cert Expiry."""
+
+DOMAIN = "cert_expiry"
+DEFAULT_NAME = "SSL Certificate Expiry"
+DEFAULT_PORT = 443
+TIMEOUT = 10.0

homeassistant/components/cert_expiry/helper.py

@@ -0,0 +1,15 @@
+"""Helper functions for the Cert Expiry platform."""
+import socket
+import ssl
+
+from .const import TIMEOUT
+
+
+def get_cert(host, port):
+    """Get the ssl certificate for the host and port combination."""
+    ctx = ssl.create_default_context()
+    address = (host, port)
+    with socket.create_connection(address, timeout=TIMEOUT) as sock:
+        with ctx.wrap_socket(sock, server_hostname=address[0]) as ssock:
+            cert = ssock.getpeercert()
+            return cert

homeassistant/components/cert_expiry/manifest.json

@@ -1,8 +1,9 @@
 {
-  "domain": "cert_expiry",
-  "name": "Cert expiry",
-  "documentation": "https://www.home-assistant.io/components/cert_expiry",
-  "requirements": [],
-  "dependencies": [],
-  "codeowners": []
+    "domain": "cert_expiry",
+    "name": "Cert expiry",
+    "documentation": "https://www.home-assistant.io/components/cert_expiry",
+    "requirements": [],
+    "config_flow": true,
+    "dependencies": [],
+    "codeowners": ["@cereal2nd"]
 }

homeassistant/components/cert_expiry/sensor.py

@@ -7,24 +7,18 @@
 import voluptuous as vol
 
 import homeassistant.helpers.config_validation as cv
+from homeassistant.config_entries import SOURCE_IMPORT
 from homeassistant.components.sensor import PLATFORM_SCHEMA
-from homeassistant.const import (
-    CONF_NAME,
-    CONF_HOST,
-    CONF_PORT,
-    EVENT_HOMEASSISTANT_START,
-)
+from homeassistant.const import CONF_NAME, CONF_HOST, CONF_PORT
 from homeassistant.helpers.entity import Entity
 
-_LOGGER = logging.getLogger(__name__)
+from .const import DOMAIN, DEFAULT_NAME, DEFAULT_PORT
+from .helper import get_cert
 
-DEFAULT_NAME = "SSL Certificate Expiry"
-DEFAULT_PORT = 443
+_LOGGER = logging.getLogger(__name__)
 
 SCAN_INTERVAL = timedelta(hours=12)
 
-TIMEOUT = 10.0
-
 PLATFORM_SCHEMA = PLATFORM_SCHEMA.extend(
     {
         vol.Required(CONF_HOST): cv.string,
@@ -34,22 +28,22 @@
 )
 
 
-def setup_platform(hass, config, add_entities, discovery_info=None):
+async def async_setup_platform(hass, config, async_add_entities, discovery_info=None):
     """Set up certificate expiry sensor."""
+    hass.async_create_task(
+        hass.config_entries.flow.async_init(
+            DOMAIN, context={"source": SOURCE_IMPORT}, data=dict(config)
+        )
+    )
 
-    def run_setup(event):
-        """Wait until Home Assistant is fully initialized before creating.
 
-        Delay the setup until Home Assistant is fully initialized.
-        """
-        server_name = config.get(CONF_HOST)
-        server_port = config.get(CONF_PORT)
-        sensor_name = config.get(CONF_NAME)
-
-        add_entities([SSLCertificate(sensor_name, server_name, server_port)], True)
-
-    # To allow checking of the HA certificate we must first be running.
-    hass.bus.listen_once(EVENT_HOMEASSISTANT_START, run_setup)
+async def async_setup_entry(hass, entry, async_add_entities):
+    """Add cert-expiry entry."""
+    async_add_entities(
+        [SSLCertificate(entry.title, entry.data[CONF_HOST], entry.data[CONF_PORT])],
+        True,
+    )
+    return True
 
 
 class SSLCertificate(Entity):
@@ -90,13 +84,8 @@ def available(self):
 
     def update(self):
         """Fetch the certificate information."""
-        ctx = ssl.create_default_context()
         try:
-            address = (self.server_name, self.server_port)
-            with socket.create_connection(address, timeout=TIMEOUT) as sock:
-                with ctx.wrap_socket(sock, server_hostname=address[0]) as ssock:
-                    cert = ssock.getpeercert()
-
+            cert = get_cert(self.server_name, self.server_port)
         except socket.gaierror:
             _LOGGER.error("Cannot resolve hostname: %s", self.server_name)
             self._available = False

homeassistant/components/cert_expiry/strings.json

@@ -0,0 +1,24 @@
+{
+    "config": {
+        "title": "Certificate Expiry",
+        "step": {
+            "user": {
+                "title": "Define the certificate to test",
+                "data": {
+                    "name": "The name of the certificate",
+                    "host": "The hostname of the certificate",
+                    "port": "The port of the certificate"
+                }
+            }
+        },
+        "error": {
+            "host_port_exists": "This host and port combination is already configured",
+            "resolve_failed": "This host can not be resolved",
+            "connection_timeout": "Timeout whemn connecting to this host",
+            "certificate_fetch_failed": "Can not fetch certificate from this host and port combination"
+        },
+        "abort": {
+            "host_port_exists": "This host and port combination is already configured"
+        }
+    }
+}

homeassistant/generated/config_flows.py

@@ -10,6 +10,7 @@
     "ambient_station",
     "axis",
     "cast",
+    "cert_expiry",
     "daikin",
     "deconz",
     "dialogflow",

tests/components/cert_expiry/__init__.py

@@ -0,0 +1 @@
+"""Tests for the Cert Expiry component."""