text: """Ban logic for HTTP component."""
  import asyncio
  from collections import defaultdict
  from datetime import datetime
  from ipaddress import ip_address
  import logging
  import os
  
  from aiohttp.web_exceptions import HTTPForbidden, HTTPUnauthorized
  import voluptuous as vol
  
  from homeassistant.components import persistent_notification
  from homeassistant.config import load_yaml_config_file
  from homeassistant.exceptions import HomeAssistantError
  import homeassistant.helpers.config_validation as cv
  from homeassistant.util.yaml import dump
  from .const import (
      KEY_BANS_ENABLED, KEY_BANNED_IPS, KEY_LOGIN_THRESHOLD,
      KEY_FAILED_LOGIN_ATTEMPTS)
  from .util import get_real_ip
  
  NOTIFICATION_ID_BAN = 'ip-ban'
  NOTIFICATION_ID_LOGIN = 'http-login'
  
  IP_BANS_FILE = 'ip_bans.yaml'
  ATTR_BANNED_AT = "banned_at"
  
  SCHEMA_IP_BAN_ENTRY = vol.Schema({
      vol.Optional('banned_at'): vol.Any(None, cv.datetime)
  })
  
  _LOGGER = logging.getLogger(__name__)
  
  
  @asyncio.coroutine
  def ban_middleware(app, handler):
      """IP Ban middleware."""
      if not app[KEY_BANS_ENABLED]:
          return handler
  
      if KEY_BANNED_IPS not in app:
          hass = app['hass']
          app[KEY_BANNED_IPS] = yield from hass.async_add_job(
              load_ip_bans_config, hass.config.path(IP_BANS_FILE))
  
      @asyncio.coroutine
      def ban_middleware_handler(request):
          """Verify if IP is not banned."""
          ip_address_ = get_real_ip(request)
  
          is_banned = any(ip_ban.ip_address == ip_address_
                          for ip_ban in request.app[KEY_BANNED_IPS])
  
          if is_banned:
              raise HTTPForbidden()
  
          try:
              return (yield from handler(request))
          except HTTPUnauthorized:
              yield from process_wrong_login(request)
              raise
  
      return ban_middleware_handler
  
  
  @asyncio.coroutine
  def process_wrong_login(request):
      """Process a wrong login attempt."""
      remote_addr = get_real_ip(request)
  
      msg = ('Login attempt or request with invalid authentication '
             'from {}'.format(remote_addr))
      _LOGGER.warning(msg)
      persistent_notification.async_create(
          request.app['hass'], msg, 'Login attempt failed',
          NOTIFICATION_ID_LOGIN)
  
      if (not request.app[KEY_BANS_ENABLED] or
              request.app[KEY_LOGIN_THRESHOLD] < 1):
          return
  
      if KEY_FAILED_LOGIN_ATTEMPTS not in request.app:
          request.app[KEY_FAILED_LOGIN_ATTEMPTS] = defaultdict(int)
  
      request.app[KEY_FAILED_LOGIN_ATTEMPTS][remote_addr] += 1
  
      if (request.app[KEY_FAILED_LOGIN_ATTEMPTS][remote_addr] >
              request.app[KEY_LOGIN_THRESHOLD]):
          new_ban = IpBan(remote_addr)
          request.app[KEY_BANNED_IPS].append(new_ban)
  
          hass = request.app['hass']
          yield from hass.async_add_job(
              update_ip_bans_config, hass.config.path(IP_BANS_FILE), new_ban)
  
          _LOGGER.warning(
              "Banned IP %s for too many login attempts", remote_addr)
  
          persistent_notification.async_create(
              hass,
              'Too many login attempts from {}'.format(remote_addr),
              'Banning IP address', NOTIFICATION_ID_BAN)
  
  
  class IpBan(object):
      """Represents banned IP address."""
  
      def __init__(self, ip_ban: str, banned_at: datetime=None) -> None:
          """Initialize IP Ban object."""
          self.ip_address = ip_address(ip_ban)
          self.banned_at = banned_at or datetime.utcnow()
  
  
  def load_ip_bans_config(path: str):
      """Load list of banned IPs from config file."""
      ip_list = []
  
      if not os.path.isfile(path):
          return ip_list
  
      try:
          list_ = load_yaml_config_file(path)
      except HomeAssistantError as err:
          _LOGGER.error('Unable to load %s: %s', path, str(err))
          return ip_list
  
      for ip_ban, ip_info in list_.items():
          try:
              ip_info = SCHEMA_IP_BAN_ENTRY(ip_info)
              ip_list.append(IpBan(ip_ban, ip_info['banned_at']))
          except vol.Invalid as err:
              _LOGGER.error("Failed to load IP ban %s: %s", ip_info, err)
              continue
  
      return ip_list
  
  
  def update_ip_bans_config(path: str, ip_ban: IpBan):
      """Update config file with new banned IP address."""
      with open(path, 'a') as out:
          ip_ = {str(ip_ban.ip_address): {
              ATTR_BANNED_AT: ip_ban.banned_at.strftime("%Y-%m-%dT%H:%M:%S")
          }}
          out.write('\n')
          out.write(dump(ip_))
  